Merge remote-tracking branch 'upstream/master'

Author: sleipnir

.tool-versions

@@ -3,8 +3,8 @@
 [![GitHub CI](https://github.com/elixir-grpc/grpc/actions/workflows/ci.yml/badge.svg)](https://github.com/elixir-grpc/grpc/actions/workflows/ci.yml)
 [![Hex.pm](https://img.shields.io/hexpm/v/grpc.svg)](https://hex.pm/packages/grpc)
 [![Hex Docs](https://img.shields.io/badge/hex-docs-lightgreen.svg)](https://hexdocs.pm/grpc/)
-[![License](https://img.shields.io/hexpm/l/grpc.svg)](https://github.com/elixir-grpc/grpc/blob/master/LICENSE.md)
-[![Total Download](https://img.shields.io/hexpm/dt/grpc.svg)](https://hex.pm/packages/elixir-grpc/grpc)
+[![License](https://img.shields.io/hexpm/l/grpc.svg)](https://github.com/elixir-grpc/grpc/blob/master/LICENSE)
+[![Total Downloads](https://img.shields.io/hexpm/dt/grpc.svg)](https://hex.pm/packages/grpc)
 [![Last Updated](https://img.shields.io/github/last-commit/elixir-grpc/grpc.svg)](https://github.com/elixir-grpc/grpc/commits/master)
 
 **gRPC Elixir** is a full-featured Elixir implementation of the [gRPC](https://grpc.io) protocol, supporting unary and streaming RPCs, interceptors, HTTP transcoding, and TLS. This version adopts a unified stream-based model for all types of calls.
@@ -34,7 +34,7 @@ def deps do
   [
     {:grpc, "~> 0.10"},
     {:protobuf, "~> 0.14"}, # optional for import wellknown google types
-    {:grpc_reflection, "~> 0.1"} # optional enable grpc reflection
+    {:grpc_reflection, "~> 0.2"} # optional enable grpc reflection
   ]
 end
 ```
@@ -150,8 +150,8 @@ defmodule Helloworld.Application do
       GrpcReflection,
       {
         GRPC.Server.Supervisor, [
-          endpoint: Helloworld.Endpoint, 
-          port: 50051, 
+          endpoint: Helloworld.Endpoint,
+          port: 50051,
           start_server: true,
           # adapter_opts: [# any adapter-specific options like tls configuration....]
         ]
@@ -162,7 +162,7 @@ defmodule Helloworld.Application do
     Supervisor.start_link(children, opts)
   end
 end
-``` 
+```
 
 # Client Usage
 
@@ -234,8 +234,8 @@ In mix.exs:
 ```elixir
 def deps do
   [
-    {:grpc, "~> 0.7"},
-    {:protobuf_generate, "~> 0.1.1"}
+    {:grpc, "~> 0.10"},
+    {:protobuf_generate, "~> 0.1.3"}
   ]
 end
 ```
@@ -268,7 +268,7 @@ See full application code in [helloworld_transcoding](examples/helloworld_transc
 
 ### **CORS**
 
-When accessing gRPC from a browser via HTTP transcoding or gRPC-Web, CORS headers may be required for the browser to allow access to the gRPC endpoint. Adding CORS headers can be done by using `GRPC.Server.Interceptors.CORS` as an interceptor in your `GRPC.Endpoint` module, configuring it as decribed in the module documentation:
+When accessing gRPC from a browser via HTTP transcoding or gRPC-Web, CORS headers may be required for the browser to allow access to the gRPC endpoint. Adding CORS headers can be done by using `GRPC.Server.Interceptors.CORS` as an interceptor in your `GRPC.Endpoint` module, configuring it as described in the module documentation:
 
 Example:
 
@@ -292,10 +292,10 @@ end
   - [Bidirectional-streaming](https://grpc.io/docs/what-is-grpc/core-concepts/#bidirectional-streaming-rpc)
 - [HTTP Transcoding](https://cloud.google.com/endpoints/docs/grpc/transcoding)
 - [TLS Authentication](https://grpc.io/docs/guides/auth/#supported-auth-mechanisms)
-- [Error handling](https://grpc.io/docs/guides/error/)
-- [Interceptors](`GRPC.Endpoint`)
+- [Error Handling](https://grpc.io/docs/guides/error/)
+- [Interceptors](https://grpc.io/docs/guides/interceptors/)
 - [Connection Backoff](https://github.com/grpc/grpc/blob/master/doc/connection-backoff.md)
-- Data compression
+- [Data Compression](https://grpc.io/docs/guides/compression/)
 - [gRPC Reflection](https://github.com/elixir-grpc/grpc-reflection)
 
 ## Benchmark

README.md

@@ -30,8 +30,10 @@ defmodule GRPC.Server.Adapters.Cowboy do
   """
   @impl true
   def start(endpoint, servers, port, opts) do
-    start_args = cowboy_start_args(endpoint, servers, port, opts)
-    start_func = if opts[:cred], do: :start_tls, else: :start_clear
+    [_ref, _trans_opts, proto_opts] =
+      start_args = cowboy_start_args(endpoint, servers, port, opts)
+
+    start_func = if cred_opts(proto_opts), do: :start_tls, else: :start_clear
 
     case apply(:cowboy, start_func, start_args) do
       {:ok, pid} ->
@@ -52,8 +54,10 @@ defmodule GRPC.Server.Adapters.Cowboy do
     [ref, trans_opts, proto_opts] = cowboy_start_args(endpoint, servers, port, opts)
     trans_opts = Map.put(trans_opts, :connection_type, :supervisor)
 
+    cred_opts = cred_opts(proto_opts)
+
     {transport, protocol} =
-      if opts[:cred] do
+      if cred_opts do
         {:ranch_ssl, :cowboy_tls}
       else
         {:ranch_tcp, :cowboy_clear}
@@ -63,7 +67,7 @@ defmodule GRPC.Server.Adapters.Cowboy do
     # So we just support both child spec versions here instead
     case :ranch.child_spec(ref, transport, trans_opts, protocol, proto_opts) do
       {ref, mfa, type, timeout, kind, modules} ->
-        scheme = if opts[:cred], do: :https, else: :http
+        scheme = if cred_opts, do: :https, else: :http
         # Wrap real mfa to print starting log
         wrapped_mfa = {__MODULE__, :start_link, [scheme, endpoint, servers, mfa]}
 
@@ -226,12 +230,12 @@ defmodule GRPC.Server.Adapters.Cowboy do
     dispatch_key = Module.concat(endpoint, Dispatch)
     :persistent_term.put(dispatch_key, dispatch)
 
-    idle_timeout = Keyword.get(opts, :idle_timeout) || :infinity
-    num_acceptors = Keyword.get(opts, :num_acceptors) || @default_num_acceptors
-    max_connections = Keyword.get(opts, :max_connections) || @default_max_connections
+    idle_timeout = Keyword.get(adapter_opts, :idle_timeout) || :infinity
+    num_acceptors = Keyword.get(adapter_opts, :num_acceptors) || @default_num_acceptors
+    max_connections = Keyword.get(adapter_opts, :max_connections) || @default_max_connections
 
     # https://ninenines.eu/docs/en/cowboy/2.7/manual/cowboy_http2/
-    opts =
+    merged_adapter_opts =
       Map.merge(
         %{
           env: %{dispatch: {:persistent_term, dispatch_key}},
@@ -245,17 +249,17 @@ defmodule GRPC.Server.Adapters.Cowboy do
           max_received_frame_rate: {10_000_000, 10_000},
           max_reset_stream_rate: {10_000, 10_000}
         },
-        Enum.into(opts, %{})
+        Enum.into(adapter_opts, %{})
       )
 
     [
       servers_name(endpoint, servers),
       %{
         num_acceptors: num_acceptors,
         max_connections: max_connections,
-        socket_opts: socket_opts(port, opts)
+        socket_opts: socket_opts(port, adapter_opts)
       },
-      opts
+      merged_adapter_opts
     ]
   end
 
@@ -270,8 +274,10 @@ defmodule GRPC.Server.Adapters.Cowboy do
         _, acc -> acc
       end)
 
-    if opts[:cred] do
-      opts[:cred].ssl ++
+    cred_opts = cred_opts(opts)
+
+    if cred_opts do
+      cred_opts.ssl ++
         [
           # These NPN/ALPN options are hardcoded in :cowboy.start_tls/3 (when calling start/3),
           # but not in :ranch.child_spec/5 (when calling child_spec/3). We must make sure they
@@ -285,6 +291,10 @@ defmodule GRPC.Server.Adapters.Cowboy do
     end
   end
 
+  defp cred_opts(opts) do
+    Kernel.get_in(opts, [:cred])
+  end
+
   defp running_info(scheme, endpoint, servers, ref) do
     {addr, port} = :ranch.get_addr(ref)
 

lib/grpc/server/adapters/cowboy.ex

@@ -77,8 +77,7 @@ defmodule GRPC.Server.Interceptors.CORS do
 
   @impl true
   def call(req, stream, next, {allow_origin, allow_headers}) do
-    if stream.access_mode != :grpc and
-         Map.get(stream.http_request_headers, "sec-fetch-mode") == "cors" do
+    if stream.access_mode != :grpc do
       headers =
         %{}
         |> add_allowed_origins(req, stream, allow_origin)

lib/grpc/server/interceptors/cors.ex

@@ -68,9 +68,14 @@ defmodule GRPC.Server.Supervisor do
 
         {:error, _} ->
           raise ArgumentError,
-                "just [:endpoint, :servers, :start_server, :port,] are accepted as arguments, and any other keys for adapters should be passed as adapter_opts!"
+                "just [:endpoint, :servers, :start_server, :port, :adapter_opts] are accepted as arguments, and any other keys for adapters should be passed as adapter_opts!"
       end
 
+    case validate_cred(opts) do
+      {:ok, _cred} -> :ok
+      {:error, err} -> raise ArgumentError, err
+    end
+
     endpoint_or_servers =
       case {opts[:endpoint], opts[:servers]} do
         {endpoint, servers}
@@ -136,4 +141,15 @@ defmodule GRPC.Server.Supervisor do
     servers = GRPC.Server.servers_to_map(servers)
     adapter.child_spec(nil, servers, port, opts)
   end
+
+  defp validate_cred(opts) do
+    with cred <- Kernel.get_in(opts, [:adapter_opts, :cred]),
+         true <- cred == nil or (is_map(cred) and is_list(Map.get(cred, :ssl))) do
+      {:ok, cred}
+    else
+      _ ->
+        {:error,
+         "the :cred option must be a map with an :ssl key containing a list of SSL options"}
+    end
+  end
 end

lib/grpc/server/supervisor.ex

@@ -6,7 +6,9 @@ defmodule GRPC.Client.Adapters.GunTest do
   describe "connect/2" do
     setup do
       server_credential = build(:credential)
-      {:ok, _, port} = GRPC.Server.start(FeatureServer, 0, cred: server_credential)
+
+      {:ok, _, port} =
+        GRPC.Server.start(FeatureServer, 0, adapter_opts: [cred: server_credential])
 
       on_exit(fn ->
         :ok = GRPC.Server.stop(FeatureServer)

test/grpc/client/adapters/gun_test.exs

@@ -18,7 +18,7 @@ defmodule GRPC.Integration.ConnectionTest do
     server = FeatureServer
     File.rm(socket_path)
 
-    {:ok, _, _} = GRPC.Server.start(server, 0, ip: {:local, socket_path})
+    {:ok, _, _} = GRPC.Server.start(server, 0, adapter_opts: [ip: {:local, socket_path}])
     {:ok, channel} = GRPC.Stub.connect(socket_path, adapter_opts: [retry_timeout: 10])
 
     point = %Routeguide.Point{latitude: 409_146_138, longitude: -746_188_906}
@@ -31,7 +31,7 @@ defmodule GRPC.Integration.ConnectionTest do
 
     cred = GRPC.Factory.build(:credential, verify: :verify_peer)
 
-    {:ok, _, port} = GRPC.Server.start(server, 0, cred: cred)
+    {:ok, _, port} = GRPC.Server.start(server, 0, adapter_opts: [cred: cred])
 
     try do
       point = %Routeguide.Point{latitude: 409_146_138, longitude: -746_188_906}

test/grpc/integration/connection_test.exs

@@ -7,11 +7,14 @@ defmodule GRPC.Server.Adapters.CowboyTest do
     test "produces the correct socket opts for ranch_tcp for inet" do
       spec =
         Cowboy.child_spec(:endpoint, [], 8080, [
-          {:foo, :bar},
-          {:ip, {127, 0, 0, 1}},
-          {:ipv6_v6only, false},
-          {:net, :inet},
-          {:baz, :foo}
+          {:adapter_opts,
+           [
+             {:foo, :bar},
+             {:ip, {127, 0, 0, 1}},
+             {:ipv6_v6only, false},
+             {:net, :inet},
+             {:baz, :foo}
+           ]}
         ])
 
       socket_opts = get_socket_opts_from_child_spec(spec)
@@ -23,11 +26,14 @@ defmodule GRPC.Server.Adapters.CowboyTest do
     test "produces the correct socket opts for ranch_tcp for inet6" do
       spec =
         Cowboy.child_spec(:endpoint, [], 8081, [
-          {:foo, :bar},
-          {:ip, {0, 0, 0, 0, 0, 0, 0, 1}},
-          {:ipv6_v6only, true},
-          {:net, :inet6},
-          {:baz, :foo}
+          {:adapter_opts,
+           [
+             {:foo, :bar},
+             {:ip, {0, 0, 0, 0, 0, 0, 0, 1}},
+             {:ipv6_v6only, true},
+             {:net, :inet6},
+             {:baz, :foo}
+           ]}
         ])
 
       socket_opts = get_socket_opts_from_child_spec(spec)

test/grpc/server/adapters/cowboy_test.exs

@@ -271,44 +271,4 @@ defmodule GRPC.Server.Interceptors.CORSTest do
       "Incorrect header when using function"
     )
   end
-
-  test "CORS only on cors sec-fetch-mode" do
-    request = %FakeRequest{}
-
-    stream = %{
-      create_stream()
-      | access_mode: :grpcweb,
-        http_request_headers: Map.put(@default_http_headers, "sec-fetch-mode", "same-origin")
-    }
-
-    {:ok, :ok} =
-      CORSInterceptor.call(
-        request,
-        %{stream | access_mode: :grpcweb},
-        fn _request, _stream -> {:ok, :ok} end,
-        CORSInterceptor.init(allow_origin: "*")
-      )
-
-    refute_received({:setting_headers, _}, "Set CORS header")
-  end
-
-  test "No CORS if missing sec-fetch-mode header" do
-    request = %FakeRequest{}
-
-    stream = %{
-      create_stream()
-      | access_mode: :grpcweb,
-        http_request_headers: Map.delete(@default_http_headers, "sec-fetch-mode")
-    }
-
-    {:ok, :ok} =
-      CORSInterceptor.call(
-        request,
-        %{stream | access_mode: :grpcweb},
-        fn _request, _stream -> {:ok, :ok} end,
-        CORSInterceptor.init(allow_origin: "*")
-      )
-
-    refute_received({:setting_headers, _}, "Set CORS header")
-  end
 end