httpx 0.12.0 → 0.14.1

data/lib/httpx/plugins/compression/deflate.rb

@@ -4,20 +4,20 @@ module HTTPX
   module Plugins
     module Compression
       module Deflate
-        def self.load_dependencies(klass)
+        def self.load_dependencies(_klass)
           require "stringio"
           require "zlib"
-          klass.plugin(:"compression/gzip")
         end
 
-        def self.configure(*)
-          Compression.register "deflate", self
+        def self.configure(klass)
+          klass.plugin(:"compression/gzip")
+          klass.default_options.encodings.register "deflate", self
         end
 
         module Deflater
           module_function
 
-          def deflate(raw, buffer, chunk_size:)
+          def deflate(raw, buffer = "".b, chunk_size: 16_384)
             deflater = Zlib::Deflate.new
             while (chunk = raw.read(chunk_size))
               compressed = deflater.deflate(chunk)
@@ -27,6 +27,7 @@ module HTTPX
             last = deflater.finish
             buffer << last
             yield last if block_given?
+            buffer
           ensure
             deflater.close if deflater
           end

data/lib/httpx/plugins/compression/gzip.rb

@@ -10,8 +10,8 @@ module HTTPX
           require "zlib"
         end
 
-        def self.configure(*)
-          Compression.register "gzip", self
+        def self.configure(klass)
+          klass.default_options.encodings.register "gzip", self
         end
 
         class Deflater
@@ -19,7 +19,7 @@ module HTTPX
             @compressed_chunk = "".b
           end
 
-          def deflate(raw, buffer, chunk_size:)
+          def deflate(raw, buffer = "".b, chunk_size: 16_384)
             gzip = Zlib::GzipWriter.new(self)
 
             begin
@@ -38,6 +38,7 @@ module HTTPX
 
             buffer << compressed
             yield compressed if block_given?
+            buffer
           end
 
           private

data/lib/httpx/plugins/cookies.rb

@@ -20,13 +20,9 @@ module HTTPX
 
       def self.extra_options(options)
         Class.new(options.class) do
-          def_option(:cookies) do |cookies|
-            if cookies.is_a?(Jar)
-              cookies
-            else
-              Jar.new(cookies)
-            end
-          end
+          def_option(:cookies, <<-OUT)
+            value.is_a?(#{Jar}) ? value : #{Jar}.new(value)
+          OUT
         end.new(options)
       end
 

data/lib/httpx/plugins/digest_authentication.rb

@@ -14,11 +14,11 @@ module HTTPX
 
       def self.extra_options(options)
         Class.new(options.class) do
-          def_option(:digest) do |digest|
-            raise Error, ":digest must be a Digest" unless digest.is_a?(Digest)
+          def_option(:digest, <<-OUT)
+            raise Error, ":digest must be a Digest" unless value.is_a?(#{Digest})
 
-            digest
-          end
+            value
+          OUT
         end.new(options)
       end
 
@@ -29,7 +29,7 @@ module HTTPX
 
       module InstanceMethods
         def digest_authentication(user, password)
-          branch(default_options.with_digest(Digest.new(user, password)))
+          with(digest: Digest.new(user, password))
         end
 
         alias_method :digest_auth, :digest_authentication

data/lib/httpx/plugins/expect.rb

@@ -16,19 +16,19 @@ module HTTPX
 
       def self.extra_options(options)
         Class.new(options.class) do
-          def_option(:expect_timeout) do |seconds|
-            seconds = Integer(seconds)
+          def_option(:expect_timeout, <<-OUT)
+            seconds = Integer(value)
             raise Error, ":expect_timeout must be positive" unless seconds.positive?
 
             seconds
-          end
+          OUT
 
-          def_option(:expect_threshold_size) do |bytes|
-            bytes = Integer(bytes)
+          def_option(:expect_threshold_size, <<-OUT)
+            bytes = Integer(value)
             raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
 
             bytes
-          end
+          OUT
         end.new(options).merge(expect_timeout: EXPECT_TIMEOUT)
       end
 

data/lib/httpx/plugins/follow_redirects.rb

@@ -19,12 +19,12 @@ module HTTPX
 
       def self.extra_options(options)
         Class.new(options.class) do
-          def_option(:max_redirects) do |num|
-            num = Integer(num)
+          def_option(:max_redirects, <<-OUT)
+            num = Integer(value)
             raise Error, ":max_redirects must be positive" if num.negative?
 
             num
-          end
+          OUT
 
           def_option(:follow_insecure_redirects)
         end.new(options)
@@ -32,7 +32,7 @@ module HTTPX
 
       module InstanceMethods
         def max_redirects(n)
-          branch(default_options.with_max_redirects(n.to_i))
+          with(max_redirects: n.to_i)
         end
 
         private

data/lib/httpx/plugins/grpc.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module HTTPX
+  GRPCError = Class.new(Error) do
+    attr_reader :status, :details, :metadata
+
+    def initialize(status, details, metadata)
+      @status = status
+      @details = details
+      @metadata = metadata
+      super("GRPC error, code=#{status}, details=#{details}, metadata=#{metadata}")
+    end
+  end
+
+  module Plugins
+    #
+    # This plugin adds DSL to build GRPC interfaces.
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/GRPC
+    #
+    module GRPC
+      unless String.method_defined?(:underscore)
+        module StringExtensions
+          refine String do
+            def underscore
+              s = dup # Avoid mutating the argument, as it might be frozen.
+              s.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              s.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+              s.tr!("-", "_")
+              s.downcase!
+              s
+            end
+          end
+        end
+        using StringExtensions
+      end
+
+      DEADLINE = 60
+      MARSHAL_METHOD = :encode
+      UNMARSHAL_METHOD = :decode
+      HEADERS = {
+        "content-type" => "application/grpc",
+        "te" => "trailers",
+        "accept" => "application/grpc",
+        # metadata fits here
+        # ex "foo-bin" => base64("bar")
+      }.freeze
+
+      class << self
+        def load_dependencies(*)
+          require "stringio"
+          require "google/protobuf"
+          require "httpx/plugins/grpc/message"
+          require "httpx/plugins/grpc/call"
+        end
+
+        def configure(klass)
+          klass.plugin(:persistent)
+          klass.plugin(:compression)
+          klass.plugin(:stream)
+        end
+
+        def extra_options(options)
+          Class.new(options.class) do
+            def_option(:grpc_service, <<-OUT)
+              String(value)
+            OUT
+
+            def_option(:grpc_compression, <<-OUT)
+              case value
+              when true, false
+                value
+              else
+                value.to_s
+              end
+            OUT
+
+            def_option(:grpc_rpcs, <<-OUT)
+              Hash[value]
+            OUT
+
+            def_option(:grpc_deadline, <<-OUT)
+              raise Error, ":grpc_deadline must be positive" unless value.positive?
+
+              value
+            OUT
+
+            def_option(:call_credentials, <<-OUT)
+              raise Error, ":call_credentials must respond to #call" unless value.respond_to?(:call)
+
+              value
+            OUT
+          end.new(options).merge(
+            fallback_protocol: "h2",
+            http2_settings: { wait_for_handshake: false },
+            grpc_rpcs: {}.freeze,
+            grpc_compression: false,
+            grpc_deadline: DEADLINE
+          )
+        end
+      end
+
+      module ResponseMethods
+        attr_reader :trailing_metadata
+
+        def merge_headers(trailers)
+          @trailing_metadata = Hash[trailers]
+          super
+        end
+
+        def encoders
+          @options.encodings
+        end
+      end
+
+      module InstanceMethods
+        def with_channel_credentials(ca_path, key = nil, cert = nil, **ssl_opts)
+          ssl_params = {
+            **ssl_opts,
+            ca_file: ca_path,
+          }
+          if key
+            key = File.read(key) if File.file?(key)
+            ssl_params[:key] = OpenSSL::PKey.read(key)
+          end
+
+          if cert
+            cert = File.read(cert) if File.file?(cert)
+            ssl_params[:cert] = OpenSSL::X509::Certificate.new(cert)
+          end
+
+          with(ssl: ssl_params)
+        end
+
+        def rpc(rpc_name, input, output, **opts)
+          rpc_name = rpc_name.to_s
+          raise Error, "rpc #{rpc_name} already defined" if @options.grpc_rpcs.key?(rpc_name)
+
+          rpc_opts = {
+            deadline: @options.grpc_deadline,
+          }.merge(opts)
+
+          with(grpc_rpcs: @options.grpc_rpcs.merge(
+            rpc_name.underscore => [rpc_name, input, output, rpc_opts]
+          ).freeze)
+        end
+
+        def build_stub(origin, service: nil, compression: false)
+          scheme = @options.ssl.empty? ? "http" : "https"
+
+          origin = URI.parse("#{scheme}://#{origin}")
+
+          with(origin: origin, grpc_service: service, grpc_compression: compression)
+        end
+
+        def execute(rpc_method, input,
+                    deadline: DEADLINE,
+                    metadata: nil,
+                    **opts)
+          grpc_request = build_grpc_request(rpc_method, input, deadline: deadline, metadata: metadata, **opts)
+          response = request(grpc_request, **opts)
+          response.raise_for_status
+          GRPC::Call.new(response, opts)
+        end
+
+        private
+
+        def rpc_execute(rpc_name, input, **opts)
+          rpc_name, input_enc, output_enc, rpc_opts = @options.grpc_rpcs[rpc_name.to_s] || raise(Error, "#{rpc_name}: undefined service")
+
+          exec_opts = rpc_opts.merge(opts)
+
+          marshal_method ||= exec_opts.delete(:marshal_method) || MARSHAL_METHOD
+          unmarshal_method ||= exec_opts.delete(:unmarshal_method) || UNMARSHAL_METHOD
+
+          messages = if input.respond_to?(:each)
+            Enumerator.new do |y|
+              input.each do |message|
+                y << input_enc.__send__(marshal_method, message)
+              end
+            end
+          else
+            input_enc.marshal(input)
+          end
+
+          call = execute(rpc_name, messages, **exec_opts)
+
+          call.decoder = output_enc.method(unmarshal_method)
+
+          call
+        end
+
+        def build_grpc_request(rpc_method, input, deadline:, metadata: nil, **)
+          uri = @options.origin.dup
+          rpc_method = "/#{rpc_method}" unless rpc_method.start_with?("/")
+          rpc_method = "/#{@options.grpc_service}#{rpc_method}" if @options.grpc_service
+          uri.path = rpc_method
+
+          headers = HEADERS.merge(
+            "grpc-accept-encoding" => ["identity", *@options.encodings.registry.keys]
+          )
+          unless deadline == Float::INFINITY
+            # convert to milliseconds
+            deadline = (deadline * 1000.0).to_i
+            headers["grpc-timeout"] = "#{deadline}m"
+          end
+
+          headers = headers.merge(metadata) if metadata
+
+          # prepare compressor
+          deflater = nil
+          compression = @options.grpc_compression == true ? "gzip" : @options.grpc_compression
+
+          if compression
+            headers["grpc-encoding"] = compression
+            deflater = @options.encodings.registry(compression).deflater
+          end
+
+          headers.merge!(@options.call_credentials.call) if @options.call_credentials
+
+          body = if input.respond_to?(:each)
+            Enumerator.new do |y|
+              input.each do |message|
+                y << Message.encode(message, deflater: deflater)
+              end
+            end
+          else
+            Message.encode(input, deflater: deflater)
+          end
+
+          build_request(:post, uri, headers: headers, body: body)
+        end
+
+        def respond_to_missing?(meth, *, &blk)
+          @options.grpc_rpcs.key?(meth.to_s) || super
+        end
+
+        def method_missing(meth, *args, **kwargs, &blk)
+          return rpc_execute(meth, *args, **kwargs, &blk) if @options.grpc_rpcs.key?(meth.to_s)
+
+          super
+        end
+      end
+    end
+    register_plugin :grpc, GRPC
+  end
+end

data/lib/httpx/plugins/grpc/call.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module GRPC
+      # Encapsulates call information
+      class Call
+        attr_writer :decoder
+
+        def initialize(response, options)
+          @response = response
+          @options = options
+          @decoder = ->(z) { z }
+        end
+
+        def inspect
+          "#GRPC::Call(#{grpc_response})"
+        end
+
+        def to_s
+          grpc_response.to_s
+        end
+
+        def metadata
+          response.headers
+        end
+
+        def trailing_metadata
+          return unless @response.body.closed?
+
+          @response.trailing_metadata
+        end
+
+        private
+
+        def grpc_response
+          return @grpc_response if defined?(@grpc_response)
+
+          @grpc_response = if @response.respond_to?(:each)
+            Enumerator.new do |y|
+              Message.stream(@response).each do |message|
+                y << @decoder.call(message)
+              end
+            end
+          else
+            @decoder.call(Message.unary(@response))
+          end
+        end
+
+        def respond_to_missing?(meth, *args, &blk)
+          grpc_response.respond_to?(meth, *args) || super
+        end
+
+        def method_missing(meth, *args, &blk)
+          return grpc_response.__send__(meth, *args, &blk) if grpc_response.respond_to?(meth)
+
+          super
+        end
+      end
+    end
+  end
+end