grpc-web 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e933d5fb31c8a64203e667339b03fe89a5b1bcfb8ddecd66c0271bef8d60f0e
-  data.tar.gz: af6dca14b9a5ba0ada4c91f1c8cf534f408cf8be77180b2553d5418491b38908
+  metadata.gz: 758ff05af92607617e668f99e32a0fb1e39e8795dd99a4d617e7de4d18a593df
+  data.tar.gz: 0fc70d8bf94ddb52d1a747590682f56750b2c57f2add9f7206cd4e20138bb998
 SHA512:
-  metadata.gz: 1e06359b9f0097781bf63e28b87e0c12746ab6c3e1a80b1d02a971420931f2f62d5d49b78b1629b70ae204e7ed9c5502346176661c4eff5fabcaec724665c602
-  data.tar.gz: 18cd177d9f793d9006ee23f1a28be8879971db60a1e970d7d77e90bb193ed324279d8de3f1bdd7c58a13e31359e9b95596a54a94f57fe7a2ca18b82930ae3141
+  metadata.gz: 4ccebf90c39a63a496dfb7d5f518f5a7edb31c62b13b62e0fd01d6162a9804c81ee1d7032c56fbc822e1b51988339904471c0017966cbc65ef2ff8aefeeccf59
+  data.tar.gz: ffce3e4c465840373a5c17ca6eff72056ddd86301e3d5743b126f664e7db51ed185fcfe3468d66cf9bd2e0a26697cab4d7a3fa26c1c926f0b7a905c4b5638e21

data/lib/grpc_web.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'grpc_web/version'
-require 'grpc_web/rack_app'
+require 'grpc_web/server/rack_app'
 
 module GRPCWeb
   class << self

data/lib/grpc_web/client/client.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'grpc_web/client/client_executor'
+
+# GRPC Client implementation
+# Example usage:
+#
+# client = GRPCWeb::Client.new("http://localhost:3000/grpc", HelloService::Service)
+# client.say_hello(name: 'James')
+class GRPCWeb::Client
+  attr_reader :base_url, :service_interface
+
+  def initialize(base_url, service_interface)
+    self.base_url = base_url
+    self.service_interface = service_interface
+
+    service_interface.rpc_descs.each do |rpc_method, rpc_desc|
+      define_rpc_method(rpc_method, rpc_desc)
+    end
+  end
+
+  private
+
+  attr_writer :base_url, :service_interface
+
+  def define_rpc_method(rpc_method, rpc_desc)
+    ruby_method = ::GRPC::GenericService.underscore(rpc_method.to_s).to_sym
+    define_singleton_method(ruby_method) do |params = {}|
+      uri = endpoint_uri(rpc_desc)
+      ::GRPCWeb::ClientExecutor.request(uri, rpc_desc, params)
+    end
+  end
+
+  def endpoint_uri(rpc_desc)
+    URI(File.join(base_url, service_interface.service_name, rpc_desc.name.to_s))
+  end
+end

data/lib/grpc_web/{client_executor.rb → client/client_executor.rb}

@@ -7,6 +7,7 @@ require 'grpc/errors'
 require 'grpc_web/content_types'
 require 'grpc_web/message_framing'
 
+# Client execution concerns
 module GRPCWeb::ClientExecutor
   class << self
     include ::GRPCWeb::ContentTypes
@@ -16,11 +17,13 @@ module GRPCWeb::ClientExecutor
 
     def request(uri, rpc_desc, params = {})
       req_proto = rpc_desc.input.new(params)
-      request_body = ::GRPCWeb::MessageFraming.frame_content(req_proto.to_proto)
+      marshalled_proto = rpc_desc.marshal_proc.call(req_proto)
+      frame = ::GRPCWeb::MessageFrame.payload_frame(marshalled_proto)
+      request_body = ::GRPCWeb::MessageFraming.pack_frames([frame])
 
       resp = post_request(uri, request_body)
       resp_body = handle_response(resp)
-      rpc_desc.output.decode(resp_body)
+      rpc_desc.unmarshal_proc(:output).call(resp_body)
     end
 
     private
@@ -35,12 +38,9 @@ module GRPCWeb::ClientExecutor
     def post_request(uri, request_body)
       request = Net::HTTP::Post.new(uri, request_headers)
       request.body = request_body
-      if uri.userinfo
-        request.basic_auth uri.user, uri.password
-      end
+      request.basic_auth uri.user, uri.password if uri.userinfo
 
-      Net::HTTP.start(uri.hostname, uri.port) do |http|
-        http.use_ssl = (uri.scheme == 'https')
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
         http.request(request)
       end
     end
@@ -50,7 +50,7 @@ module GRPCWeb::ClientExecutor
         raise "Received #{resp.code} #{resp.message} response: #{resp.body}"
       end
 
-      frames = ::GRPCWeb::MessageFraming.unframe_content(resp.body)
+      frames = ::GRPCWeb::MessageFraming.unpack_frames(resp.body)
       header_frame = frames.find(&:header?)
       headers = parse_headers(header_frame.body) if header_frame
       raise_on_error(headers)

data/lib/grpc_web/content_types.rb

@@ -15,5 +15,5 @@ module GRPCWeb::ContentTypes
     TEXT_CONTENT_TYPE,
     TEXT_PROTO_CONTENT_TYPE,
   ].freeze
-  ANY_CONTENT_TYPES = ['*/*', ''].freeze
+  UNSPECIFIED_CONTENT_TYPES = ['*/*', '', nil].freeze
 end

data/lib/grpc_web/message_frame.rb

@@ -1,31 +1,34 @@
 # frozen_string_literal: true
 
-module GRPCWeb
-  class MessageFrame
-    PAYLOAD_FRAME_TYPE = 0 # String: "\x00"
-    HEADER_FRAME_TYPE = 128 # String: "\x80"
+# Placeholder
+class GRPCWeb::MessageFrame
+  PAYLOAD_FRAME_TYPE = 0 # String: "\x00"
+  HEADER_FRAME_TYPE = 128 # String: "\x80"
 
-    def self.payload_frame(body)
-      new(PAYLOAD_FRAME_TYPE, body)
-    end
+  def self.payload_frame(body)
+    new(PAYLOAD_FRAME_TYPE, body)
+  end
+
+  def self.header_frame(body)
+    new(HEADER_FRAME_TYPE, body)
+  end
 
-    def self.header_frame(body)
-      new(HEADER_FRAME_TYPE, body)
-    end
+  attr_accessor :frame_type, :body
 
-    attr_accessor :frame_type, :body
+  def initialize(frame_type, body)
+    self.frame_type = frame_type
+    self.body = body.b # treat body as a byte string
+  end
 
-    def initialize(frame_type, body)
-      self.frame_type = frame_type
-      self.body = body
-    end
+  def payload?
+    frame_type == PAYLOAD_FRAME_TYPE
+  end
 
-    def payload?
-      frame_type == PAYLOAD_FRAME_TYPE
-    end
+  def header?
+    frame_type == HEADER_FRAME_TYPE
+  end
 
-    def header?
-      frame_type == HEADER_FRAME_TYPE
-    end
+  def ==(other)
+    frame_type == other.frame_type && body == other.body
   end
 end

data/lib/grpc_web/message_framing.rb

@@ -1,50 +1,32 @@
 # frozen_string_literal: true
 
-require 'grpc_web/grpc_web_response'
-require 'grpc_web/grpc_web_request'
 require 'grpc_web/message_frame'
 
-module GRPCWeb
-  # GRPC Web uses a simple 5 byte framing scheme. The first byte represents
-  # flags indicating what type of frame this is. The next 4 bytes indicate the
-  # byte length of the frame body.
-  module MessageFraming
-    class << self
-      def unframe_request(request)
-        frames = unframe_content(request.body)
-        ::GRPCWeb::GRPCWebRequest.new(
-          request.service, request.service_method, request.content_type, request.accept, frames,
-        )
-      end
-
-      def frame_response(response)
-        framed = response.body.map do |frame|
-          frame_content(frame.body, frame.frame_type)
-        end.join
-        ::GRPCWeb::GRPCWebResponse.new(response.content_type, framed)
-      end
-
-      def frame_content(content, frame_type = ::GRPCWeb::MessageFrame::PAYLOAD_FRAME_TYPE)
-        length_bytes = [content.bytesize].pack('N')
-        "#{frame_type.chr}#{length_bytes}#{content}"
-      end
+# Placeholder
+module GRPCWeb::MessageFraming
+  class << self
+    def pack_frames(frames)
+      frames.map do |frame|
+        length_bytes = [frame.body.bytesize].pack('N')
+        "#{frame.frame_type.chr}#{length_bytes}#{frame.body}"
+      end.join
+    end
 
-      def unframe_content(content)
-        frames = []
-        remaining_content = content
-        until remaining_content.empty?
-          msg_length = remaining_content[1..4].unpack1('N')
-          raise 'Invalid message length' if msg_length <= 0
+    def unpack_frames(content)
+      frames = []
+      remaining_content = content
+      until remaining_content.empty?
+        msg_length = remaining_content[1..4].unpack1('N')
+        raise 'Invalid message length' if msg_length <= 0
 
-          frame_end = 5 + msg_length
-          frames << ::GRPCWeb::MessageFrame.new(
-            remaining_content[0].bytes[0],
-            remaining_content[5...frame_end],
-          )
-          remaining_content = remaining_content[frame_end..-1]
-        end
-        frames
+        frame_end = 5 + msg_length
+        frames << ::GRPCWeb::MessageFrame.new(
+          remaining_content[0].bytes[0],
+          remaining_content[5...frame_end],
+        )
+        remaining_content = remaining_content[frame_end..-1]
       end
+      frames
     end
   end
 end

data/lib/grpc_web/{error_callback.rb → server/error_callback.rb}

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+# Placeholder
 module GRPCWeb
   class << self
     NOOP_ON_ERROR = proc { |ex, service, service_method| }

data/lib/grpc_web/{grpc_request_processor.rb → server/grpc_request_processor.rb}

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
 require 'grpc_web/content_types'
-require 'grpc_web/error_callback'
 require 'grpc_web/grpc_web_response'
-require 'grpc_web/message_framing'
-require 'grpc_web/message_serialization'
-require 'grpc_web/text_coder'
+require 'grpc_web/server/request_framing'
+require 'grpc_web/server/error_callback'
+require 'grpc_web/server/message_serialization'
+require 'grpc_web/server/text_coder'
 
+# Placeholder
 module GRPCWeb::GRPCRequestProcessor
   class << self
     include ::GRPCWeb::ContentTypes
 
     def process(grpc_web_request)
       text_coder = ::GRPCWeb::TextCoder
-      framing = ::GRPCWeb::MessageFraming
+      framing = ::GRPCWeb::RequestFraming
       serialization = ::GRPCWeb::MessageSerialization
 
       grpc_web_request = text_coder.decode_request(grpc_web_request)
@@ -41,7 +42,7 @@ module GRPCWeb::GRPCRequestProcessor
 
     # Use Accept header value if specified, otherwise use request content type
     def response_content_type(request)
-      if request.accept.nil? || ANY_CONTENT_TYPES.include?(request.accept)
+      if UNSPECIFIED_CONTENT_TYPES.include?(request.accept)
         request.content_type
       else
         request.accept

data/lib/grpc_web/{message_serialization.rb → server/message_serialization.rb}

@@ -7,6 +7,7 @@ require 'grpc_web/grpc_web_response'
 require 'grpc_web/grpc_web_request'
 require 'grpc_web/message_frame'
 
+# Placeholder
 module GRPCWeb::MessageSerialization
   class << self
     include ::GRPCWeb::ContentTypes
@@ -72,7 +73,7 @@ module GRPCWeb::MessageSerialization
     # If needed, trailers can be appended to the response as a 2nd
     # base64 encoded string with independent framing.
     def generate_headers(status, message)
-      header_str = [
+      [
         "grpc-status:#{status}",
         "grpc-message:#{message}",
         'x-grpc-web:1',

data/lib/grpc_web/server/rack_app.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rack/builder'
+require 'grpc_web/server/rack_handler'
+require 'grpc_web/server/service_class_validator'
+
+# Can be given a service class, an instance of a service class, or a
+# service interface class with a block to lazily initialize the service.
+#
+# Example 1:
+#   app.handle(TestHelloService)
+#
+# Example 2:
+#   app.handle(TestHelloService.new)
+#
+# Example 3:
+#   app.handle(HelloService::Service) do
+#     require 'test_hello_service'
+#     TestHelloService.new
+#   end
+#
+# TODO: in-mem cache the result of lazy initialization
+class GRPCWeb::RackApp < ::Rack::Builder
+  def handle(service_or_class, &lazy_init_block)
+    service_class = service_or_class.is_a?(Class) ? service_or_class : service_or_class.class
+    GRPCWeb::ServiceClassValidator.validate(service_class)
+    service_config = lazy_init_block || service_or_class
+
+    service_class.rpc_descs.keys.each do |service_method|
+      add_service_method_to_app(service_class.service_name, service_config, service_method)
+    end
+  end
+
+  private
+
+  # Map a path with Rack::Builder corresponding to the service method
+  def add_service_method_to_app(service_name, service_config, service_method)
+    map("/#{service_name}/#{service_method}") do
+      run(RouteHandler.new(service_config, service_method))
+    end
+  end
+
+  # Handles a single route
+  class RouteHandler
+    def initialize(service_config, service_method)
+      self.service_config = service_config
+      self.service_method = service_method
+    end
+
+    def call(env)
+      ::GRPCWeb::RackHandler.call(service, service_method, env)
+    end
+
+    private
+
+    attr_accessor :service_config, :service_method
+
+    def service
+      case service_config
+      when Proc
+        service_config.call
+      when Class
+        service_config.new
+      else
+        service_config
+      end
+    end
+  end
+end

data/lib/grpc_web/server/rack_handler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'google/protobuf'
+require 'rack'
+require 'rack/request'
+require 'grpc_web/content_types'
+require 'grpc_web/grpc_web_request'
+require 'grpc_web/server/error_callback'
+require 'grpc_web/server/grpc_request_processor'
+
+# Placeholder
+module GRPCWeb::RackHandler
+  NOT_FOUND = 404
+  UNSUPPORTED_MEDIA_TYPE = 415
+  INTERNAL_SERVER_ERROR = 500
+  ACCEPT_HEADER = 'HTTP_ACCEPT'
+
+  class << self
+    include ::GRPCWeb::ContentTypes
+
+    def call(service, service_method, env)
+      rack_request = Rack::Request.new(env)
+      return not_found_response(rack_request.path) unless rack_request.post?
+      return unsupported_media_type_response unless valid_content_types?(rack_request)
+
+      content_type = rack_request.content_type
+      accept = rack_request.get_header(ACCEPT_HEADER)
+      body = rack_request.body.read
+      request = GRPCWeb::GRPCWebRequest.new(service, service_method, content_type, accept, body)
+      response = GRPCWeb::GRPCRequestProcessor.process(request)
+
+      [200, { 'Content-Type' => response.content_type }, [response.body]]
+    rescue Google::Protobuf::ParseError => e
+      invalid_response(e.message)
+    rescue StandardError => e
+      ::GRPCWeb.on_error.call(e, service, service_method)
+      error_response
+    end
+
+    private
+
+    def valid_content_types?(rack_request)
+      return false unless ALL_CONTENT_TYPES.include?(rack_request.content_type)
+
+      accept = rack_request.get_header(ACCEPT_HEADER)
+      return true if UNSPECIFIED_CONTENT_TYPES.include?(accept)
+
+      ALL_CONTENT_TYPES.include?(accept)
+    end
+
+    def not_found_response(path)
+      [
+        NOT_FOUND,
+        { 'Content-Type' => 'text/plain', 'X-Cascade' => 'pass' },
+        ["Not Found: #{path}"],
+      ]
+    end
+
+    def unsupported_media_type_response
+      [
+        UNSUPPORTED_MEDIA_TYPE,
+        { 'Content-Type' => 'text/plain' },
+        ['Unsupported Media Type: Invalid Content-Type or Accept header'],
+      ]
+    end
+
+    def invalid_response(message)
+      [422, { 'Content-Type' => 'text/plain' }, ["Invalid request format: #{message}"]]
+    end
+
+    def error_response
+      [
+        INTERNAL_SERVER_ERROR,
+        { 'Content-Type' => 'text/plain' },
+        ['Request failed with an unexpected error.'],
+      ]
+    end
+  end
+end

data/lib/grpc_web/server/request_framing.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'grpc_web/grpc_web_response'
+require 'grpc_web/grpc_web_request'
+require 'grpc_web/message_framing'
+
+# Framing concerns for handling a request on the server
+module GRPCWeb::RequestFraming
+  class << self
+    def unframe_request(request)
+      frames = message_framing.unpack_frames(request.body)
+      ::GRPCWeb::GRPCWebRequest.new(
+        request.service, request.service_method, request.content_type, request.accept, frames,
+      )
+    end
+
+    def frame_response(response)
+      frames = message_framing.pack_frames(response.body)
+      ::GRPCWeb::GRPCWebResponse.new(response.content_type, frames)
+    end
+
+    private
+
+    def message_framing
+      ::GRPCWeb::MessageFraming
+    end
+  end
+end

data/lib/grpc_web/server/service_class_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Validates that clazz is a grpc service class
+module GRPCWeb::ServiceClassValidator
+  def self.validate(clazz)
+    unless clazz.include?(::GRPC::GenericService)
+      raise(ArgumentError, "#{clazz} must 'include GenericService'")
+    end
+    if clazz.rpc_descs.size.zero?
+      raise(ArgumentError, "#{clazz} should specify some rpc descriptions")
+    end
+
+    true
+  end
+end

data/lib/grpc_web/{text_coder.rb → server/text_coder.rb}

@@ -5,6 +5,7 @@ require 'grpc_web/content_types'
 require 'grpc_web/grpc_web_response'
 require 'grpc_web/grpc_web_request'
 
+# Placeholder
 module GRPCWeb::TextCoder
   class << self
     include ::GRPCWeb::ContentTypes

data/lib/grpc_web/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GRPCWeb
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grpc-web
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - James Shkolnik
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2020-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grpc
@@ -156,6 +156,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Host gRPC-Web endpoints for Ruby gRPC services in a Rack or Rails app(over
   HTTP/1.1). Client included.
 email:
@@ -166,19 +180,21 @@ extra_rdoc_files: []
 files:
 - lib/grpc-web.rb
 - lib/grpc_web.rb
-- lib/grpc_web/client.rb
-- lib/grpc_web/client_executor.rb
+- lib/grpc_web/client/client.rb
+- lib/grpc_web/client/client_executor.rb
 - lib/grpc_web/content_types.rb
-- lib/grpc_web/error_callback.rb
-- lib/grpc_web/grpc_request_processor.rb
 - lib/grpc_web/grpc_web_request.rb
 - lib/grpc_web/grpc_web_response.rb
 - lib/grpc_web/message_frame.rb
 - lib/grpc_web/message_framing.rb
-- lib/grpc_web/message_serialization.rb
-- lib/grpc_web/rack_app.rb
-- lib/grpc_web/rack_handler.rb
-- lib/grpc_web/text_coder.rb
+- lib/grpc_web/server/error_callback.rb
+- lib/grpc_web/server/grpc_request_processor.rb
+- lib/grpc_web/server/message_serialization.rb
+- lib/grpc_web/server/rack_app.rb
+- lib/grpc_web/server/rack_handler.rb
+- lib/grpc_web/server/request_framing.rb
+- lib/grpc_web/server/service_class_validator.rb
+- lib/grpc_web/server/text_coder.rb
 - lib/grpc_web/version.rb
 homepage: https://github.com/gusto/grpc-web-ruby
 licenses:

data/lib/grpc_web/client.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'uri'
-require 'grpc_web/client_executor'
-
-module GRPCWeb
-  class Client
-    attr_reader :base_url, :service_interface
-
-    def initialize(base_url, service_interface)
-      self.base_url = base_url
-      self.service_interface = service_interface
-
-      service_interface.rpc_descs.each do |rpc_method, rpc_desc|
-        define_rpc_method(rpc_method, rpc_desc)
-      end
-    end
-
-    private
-
-    attr_writer :base_url, :service_interface
-
-    def define_rpc_method(rpc_method, rpc_desc)
-      ruby_method = ::GRPC::GenericService.underscore(rpc_method.to_s).to_sym
-      define_singleton_method(ruby_method) do |params = {}|
-        uri = endpoint_uri(rpc_desc)
-        ::GRPCWeb::ClientExecutor.request(uri, rpc_desc, params)
-      end
-    end
-
-    def endpoint_uri(rpc_desc)
-      URI(File.join(base_url, service_interface.service_name, rpc_desc.name.to_s))
-    end
-  end
-end

data/lib/grpc_web/rack_app.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/builder'
-require 'grpc_web/rack_handler'
-
-module GRPCWeb
-  class RackApp < ::Rack::Builder
-    # Can be given a service class, an instance of a service class, or a
-    # service interface class with a block to lazily initialize the service.
-    #
-    # Example 1:
-    #   app.handle(TestHelloService)
-    #
-    # Example 2:
-    #   app.handle(TestHelloService.new)
-    #
-    # Example 3:
-    #   app.handle(HelloService::Service) do
-    #     require 'test_hello_service'
-    #     TestHelloService.new
-    #   end
-    #
-    def handle(service_or_class, &lazy_init_block)
-      service_class = service_or_class.is_a?(Class) ? service_or_class : service_or_class.class
-      validate_service_class(service_class)
-      service_config = lazy_init_block || service_or_class
-
-      service_class.rpc_descs.keys.each do |service_method|
-        add_service_method_to_app(service_class.service_name, service_config, service_method)
-      end
-    end
-
-    private
-
-    def validate_service_class(clazz)
-      unless clazz.include?(::GRPC::GenericService)
-        raise(ArgumentError, "#{clazz} must 'include GenericService'")
-      end
-      if clazz.rpc_descs.size.zero?
-        raise(ArgumentError, "#{clazz} should specify some rpc descriptions")
-      end
-    end
-
-    # Map a path with Rack::Builder corresponding to the service method
-    def add_service_method_to_app(service_name, service_config, service_method)
-      map("/#{service_name}/#{service_method}") do
-        run(RouteHandler.new(service_config, service_method))
-      end
-    end
-
-    class RouteHandler
-      def initialize(service_config, service_method)
-        self.service_config = service_config
-        self.service_method = service_method
-      end
-
-      def call(env)
-        ::GRPCWeb::RackHandler.call(service, service_method, env)
-      end
-
-      private
-
-      attr_accessor :service_config, :service_method
-
-      def service
-        case service_config
-        when Proc
-          service_config.call
-        when Class
-          service_config.new
-        else
-          service_config
-        end
-      end
-    end
-  end
-end

data/lib/grpc_web/rack_handler.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'rack/request'
-require 'grpc_web/content_types'
-require 'grpc_web/error_callback'
-require 'grpc_web/grpc_request_processor'
-require 'grpc_web/grpc_web_request'
-
-module GRPCWeb
-  module RackHandler
-    NOT_FOUND = 404
-    UNSUPPORTED_MEDIA_TYPE = 415
-    INTERNAL_SERVER_ERROR = 500
-    POST = 'POST'
-    ACCEPT_HEADER = 'HTTP_ACCEPT'
-
-    class << self
-      include ::GRPCWeb::ContentTypes
-
-      def call(service, service_method, env)
-        rack_request = Rack::Request.new(env)
-        return not_found_response(rack_request.path) unless post?(rack_request)
-        return unsupported_media_type_response unless valid_content_types?(rack_request)
-
-        request_format = rack_request.content_type
-        accept = rack_request.get_header(ACCEPT_HEADER)
-        body = rack_request.body.read
-        request = GRPCWebRequest.new(service, service_method, request_format, accept, body)
-        response = GRPCRequestProcessor.process(request)
-
-        [200, { 'Content-Type' => response.content_type }, [response.body]]
-      rescue Google::Protobuf::ParseError => e
-        invalid_response(e.message)
-      rescue StandardError => e
-        ::GRPCWeb.on_error.call(e, service, service_method)
-        error_response
-      end
-
-      private
-
-      def post?(rack_request)
-        rack_request.request_method == POST
-      end
-
-      def valid_content_types?(rack_request)
-        return false unless ALL_CONTENT_TYPES.include?(rack_request.content_type)
-
-        accept = rack_request.get_header(ACCEPT_HEADER)
-        return true if ANY_CONTENT_TYPES.include?(accept)
-
-        ALL_CONTENT_TYPES.include?(accept)
-      end
-
-      def not_found_response(path)
-        [
-          NOT_FOUND,
-          { 'Content-Type' => 'text/plain', 'X-Cascade' => 'pass' },
-          ["Not Found: #{path}"],
-        ]
-      end
-
-      def unsupported_media_type_response
-        [
-          UNSUPPORTED_MEDIA_TYPE,
-          { 'Content-Type' => 'text/plain' },
-          ['Unsupported Media Type: Invalid Content-Type or Accept header'],
-        ]
-      end
-
-      def invalid_response(message)
-        [422, { 'Content-Type' => 'text/plain' }, ["Invalid request format: #{message}"]]
-      end
-
-      def error_response
-        [
-          INTERNAL_SERVER_ERROR,
-          { 'Content-Type' => 'text/plain' },
-          ['Request failed with an unexpected error.'],
-        ]
-      end
-    end
-  end
-end