From 727459ec92477aa474ba96e39dc9158ef16c5c6f Mon Sep 17 00:00:00 2001 From: Luke Imhoff Date: Tue, 21 Aug 2018 11:14:12 -0500 Subject: [PATCH] Use `socket`'s Socket.Web for another implementation of WebSockets --- .credo.exs | 4 +- .../{web_sockex => }/registration.ex | 6 +- .../lib/ethereum_jsonrpc/web_socket/socket.ex | 338 ++++++++++++++++++ .../web_socket/socket/receiver.ex | 71 ++++ .../ethereum_jsonrpc/web_socket/web_sockex.ex | 2 +- apps/ethereum_jsonrpc/mix.exs | 6 +- .../ethereum_jsonrpc/web_socket/case/geth.ex | 2 +- .../web_socket/case/parity.ex | 2 +- mix.lock | 1 + 9 files changed, 424 insertions(+), 8 deletions(-) rename apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/{web_sockex => }/registration.ex (83%) create mode 100644 apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket.ex create mode 100644 apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket/receiver.ex diff --git a/.credo.exs b/.credo.exs index 604639c40e..7cae86277c 100644 --- a/.credo.exs +++ b/.credo.exs @@ -75,7 +75,9 @@ # Priority values are: `low, normal, high, higher` # {Credo.Check.Design.AliasUsage, - excluded_lastnames: ~w(Address DateTime Full Number Repo Time Unit), priority: :low}, + excluded_namespaces: ~w(Socket Task), + excluded_lastnames: ~w(Address DateTime Full Number Repo Time Unit), + priority: :low}, # For some checks, you can also set other parameters # diff --git a/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex/registration.ex b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/registration.ex similarity index 83% rename from apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex/registration.ex rename to apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/registration.ex index ecbe7b341f..d53b6dc61f 100644 --- a/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex/registration.ex +++ b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/registration.ex @@ -1,6 +1,6 @@ -defmodule EthereumJSONRPC.WebSocket.WebSockex.Registration do +defmodule EthereumJSONRPC.WebSocket.Registration do @moduledoc """ - When a caller registers for responses to asynchronous `WebSockex.send_frame` responses. + When a caller registers for responses to asynchronous frame responses. """ alias EthereumJSONRPC.Subscription @@ -18,7 +18,7 @@ defmodule EthereumJSONRPC.WebSocket.WebSockex.Registration do * `:unsubscribe` - an `eth_unsubscribe` request will be issued by the caller. Its response needs to be returned to caller **AND** the client needs to stop tracking the subscription. """ - @type type :: :json_rpc | :subscribe + @type type :: :json_rpc | :subscribe | :unsubscribe @type t :: %__MODULE__{from: GenServer.from(), type: type, subscription_id: Subscription.id()} end diff --git a/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket.ex b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket.ex new file mode 100644 index 0000000000..ef727c826a --- /dev/null +++ b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket.ex @@ -0,0 +1,338 @@ +defmodule EthereumJSONRPC.WebSocket.Socket do + @moduledoc """ + Implements `EthereumJSONRPC.WebSocket` using `Socket.Web`. + """ + + use GenServer + + require Logger + + import EthereumJSONRPC, only: [request: 1] + + alias EthereumJSONRPC.{Subscription, Transport, WebSocket} + alias EthereumJSONRPC.WebSocket.Registration + alias EthereumJSONRPC.WebSocket.Socket.Receiver + + @behaviour WebSocket + + @enforce_keys ~w(receiver socket_web url)a + defstruct receiver: nil, + request_id_to_registration: %{}, + socket_web: nil, + subscription_id_to_subscription: %{}, + url: nil + + @type t :: %__MODULE__{ + receiver: pid(), + request_id_to_registration: %{non_neg_integer() => Registration.t()}, + socket_web: Socket.Web.t(), + subscription_id_to_subscription: %{Subscription.id() => Subscription.t()}, + url: String.t() + } + + # Supervisor interface + + @impl WebSocket + # only allow secure WSS + def start_link(["wss://" <> _ = url, gen_server_options]) when is_list(gen_server_options) do + GenServer.start_link(__MODULE__, url, gen_server_options) + end + + # Client interface + + @impl WebSocket + @spec json_rpc(WebSocket.web_socket(), Transport.request()) :: {:ok, Transport.result()} | {:error, reason :: term()} + def json_rpc(web_socket, request) do + GenServer.call(web_socket, {:json_rpc, request}) + end + + @impl WebSocket + @spec subscribe(WebSocket.web_socket(), Subscription.event(), Subscription.params()) :: + {:ok, Subscription.t()} | {:error, reason :: term()} + def subscribe(web_socket, event, params) when is_binary(event) and is_list(params) do + GenServer.call(web_socket, {:subscribe, event, params}) + end + + @impl WebSocket + @spec unsubscribe(WebSocket.web_socket(), Subscription.t()) :: :ok | {:error, :not_found} + def unsubscribe(web_socket, %Subscription{} = subscription) do + GenServer.call(web_socket, {:unsubscribe, subscription}) + end + + @impl GenServer + def init("wss://" <> _ = url) do + uri = URI.parse(url) + address = uri_to_address(uri) + + options = + options_put_uri( + [ + authorities: [path: :certifi.cacertfile()], + partial_chain: &partial_chain/1, + secure: true, + server_name: uri.host, + verify: [function: &:ssl_verify_hostname.verify_fun/3, data: [check_hostname: String.to_charlist(uri.host)]] + ], + uri + ) + + case Socket.Web.connect(address, options) do + {:ok, socket_web} -> + receiver = Receiver.spawn_link(%{parent: self(), socket_web: socket_web}) + {:ok, %__MODULE__{receiver: receiver, socket_web: socket_web, url: url}} + + {:error, reason} -> + {:stop, reason} + end + end + + @impl GenServer + def handle_call(message, from, %__MODULE__{socket_web: socket_web} = state) do + {updated_state, unique_request} = register(message, from, state) + + Socket.Web.send(socket_web, {:text, Jason.encode!(unique_request)}) + + {:noreply, updated_state} + end + + @impl GenServer + def handle_cast({:text, text}, %__MODULE__{} = state) do + case Jason.decode(text) do + {:ok, json} -> + handle_response(json, state) + + {:error, _} = error -> + broadcast(error, state) + {:noreply, state} + end + end + + def handle_cast(:close = close, %__MODULE__{} = state) do + broadcast({:error, close}, state) + end + + def handle_cast({:close, _code, _data} = close, %__MODULE__{} = state) do + broadcast({:error, close}, state) + end + + def handle_cast({:error, _reason} = error, %__MODULE__{} = state) do + broadcast(error, state) + end + + defp broadcast(message, %__MODULE__{subscription_id_to_subscription: id_to_subscription}) do + id_to_subscription + |> Map.values() + |> Subscription.broadcast(message) + end + + defp handle_response( + %{"method" => "eth_subscription", "params" => %{"result" => result, "subscription" => subscription_id}}, + %__MODULE__{subscription_id_to_subscription: subscription_id_to_subscription} = state + ) do + case subscription_id_to_subscription do + %{^subscription_id => subscription} -> + Subscription.publish(subscription, {:ok, result}) + + _ -> + Logger.error(fn -> + [ + "Unexpected `eth_subscription` subscription ID (", + inspect(subscription_id), + ") result (", + inspect(result), + "). Subscription ID not in known subscription IDs (", + subscription_id_to_subscription + |> Map.values() + |> Enum.map(&inspect/1), + ")." + ] + end) + end + + {:noreply, state} + end + + defp handle_response( + %{"id" => id} = response, + %__MODULE__{request_id_to_registration: request_id_to_registration} = state + ) do + {registration, new_request_id_to_registration} = Map.pop(request_id_to_registration, id) + respond_to_registration(registration, new_request_id_to_registration, response, state) + end + + defp handle_response(response, %__MODULE__{} = state) do + Logger.error(fn -> + [ + "Unexpected JSON response from web socket\n", + "\n", + " Response:\n", + " ", + inspect(response) + ] + end) + + {:noreply, state} + end + + defp options_put_uri(options, %URI{path: nil}), do: options + + defp options_put_uri(options, %URI{path: path}) when is_binary(path) do + Keyword.put(options, :path, path) + end + + defp partial_chain(certs) do + raise "BBOOM: #{inspect certs}" + end + + defp register( + {:json_rpc, original_request}, + from, + %__MODULE__{request_id_to_registration: request_id_to_registration} = state + ) do + unique_id = unique_request_id(state) + + {%__MODULE__{ + state + | request_id_to_registration: + Map.put(request_id_to_registration, unique_id, %Registration{ + from: from, + type: :json_rpc + }) + }, %{original_request | id: unique_id}} + end + + defp register( + {:subscribe, event, params}, + from, + %__MODULE__{request_id_to_registration: request_id_to_registration} = state + ) + when is_binary(event) and is_list(params) do + unique_id = unique_request_id(state) + + { + %__MODULE__{ + state + | request_id_to_registration: + Map.put(request_id_to_registration, unique_id, %Registration{from: from, type: :subscribe}) + }, + request(%{id: unique_id, method: "eth_subscribe", params: [event | params]}) + } + end + + defp register( + {:unsubscribe, %Subscription{id: subscription_id}}, + from, + %__MODULE__{request_id_to_registration: request_id_to_registration} = state + ) do + unique_id = unique_request_id(state) + + { + %__MODULE__{ + state + | request_id_to_registration: + Map.put(request_id_to_registration, unique_id, %Registration{ + from: from, + type: :unsubscribe, + subscription_id: subscription_id + }) + }, + request(%{id: unique_id, method: "eth_unsubscribe", params: [subscription_id]}) + } + end + + defp unique_request_id(%__MODULE__{request_id_to_registration: request_id_to_registration} = state) do + unique_request_id = EthereumJSONRPC.unique_request_id() + + case request_id_to_registration do + # collision + %{^unique_request_id => _} -> + unique_request_id(state) + + _ -> + unique_request_id + end + end + + defp respond_to_registration( + %Registration{type: :json_rpc, from: from}, + new_request_id_to_registration, + response, + %__MODULE__{} = state + ) do + reply = + case response do + %{"result" => result} -> {:ok, result} + %{"error" => error} -> {:error, error} + end + + GenServer.reply(from, reply) + + {:noreply, %__MODULE__{state | request_id_to_registration: new_request_id_to_registration}} + end + + defp respond_to_registration( + %Registration{type: :subscribe, from: {subscriber_pid, _} = from}, + new_request_id_to_registration, + %{"result" => subscription_id}, + %__MODULE__{url: url} = state + ) do + subscription = %Subscription{ + id: subscription_id, + subscriber_pid: subscriber_pid, + transport: EthereumJSONRPC.WebSocket, + transport_options: [web_socket: __MODULE__, web_socket_options: %{web_socket: self()}, url: url] + } + + GenServer.reply(from, {:ok, subscription}) + + new_state = + state + |> put_in([Access.key!(:request_id_to_registration)], new_request_id_to_registration) + |> put_in([Access.key!(:subscription_id_to_subscription), subscription_id], subscription) + + {:noreply, new_state} + end + + defp respond_to_registration( + %Registration{type: :subscribe, from: from}, + new_request_id_to_registration, + %{"error" => error}, + %__MODULE__{} = state + ) do + GenServer.reply(from, {:error, error}) + + {:noreply, %__MODULE__{state | request_id_to_registration: new_request_id_to_registration}} + end + + defp respond_to_registration( + %Registration{type: :unsubscribe, from: from, subscription_id: subscription_id}, + new_request_id_to_registration, + response, + %__MODULE__{} = state + ) do + reply = + case response do + %{"result" => true} -> :ok + %{"result" => false} -> {:error, :not_found} + %{"error" => error} -> {:error, error} + end + + GenServer.reply(from, reply) + + new_state = + state + |> put_in([Access.key!(:request_id_to_registration)], new_request_id_to_registration) + |> update_in([Access.key!(:subscription_id_to_subscription)], &Map.delete(&1, subscription_id)) + + {:noreply, new_state} + end + + defp respond_to_registration(nil, _, response, %__MODULE__{} = state) do + Logger.error(fn -> ["Got response for unregistered request ID: ", inspect(response)] end) + + {:noreply, state} + end + + defp uri_to_address(%URI{host: host, port: nil}), do: host + defp uri_to_address(%URI{host: host, port: port}) when is_integer(port), do: {host, port} +end diff --git a/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket/receiver.ex b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket/receiver.ex new file mode 100644 index 0000000000..4994eb63f5 --- /dev/null +++ b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/socket/receiver.ex @@ -0,0 +1,71 @@ +defmodule EthereumJSONRPC.WebSocket.Socket.Receiver do + @moduledoc """ + Receives WebSocket messages with `Socket.Web.recv` and send non-ping/pong messages on to `EthereumJSONRPC.WebSocket.Socket` + """ + + @enforce_keys ~w(parent socket_web)a + defstruct fragments_type: nil, + fragments: [], + parent: nil, + socket_web: nil + + def spawn_link(named_arguments) do + spawn_link(__MODULE__, :loop, [struct!(__MODULE__, named_arguments)]) + end + + @doc false + def loop(%__MODULE__{socket_web: socket_web} = state) do + loop(state, Socket.Web.recv(socket_web)) + end + + # start of fragment + defp loop(state, {:ok, {:fragmented, type, fragment}}) when type in ~w(binary text)a do + loop(%__MODULE__{state | fragments_type: type, fragments: [fragment]}) + end + + # middle of fragment + defp loop(%__MODULE__{fragments: fragments} = state, {:ok, {:fragmented, :continuation, fragment}}) do + loop(%__MODULE__{state | fragments: [fragments | fragment]}) + end + + # end of fragment + defp loop( + %__MODULE__{fragments_type: fragments_type, fragments: fragments, parent: parent} = state, + {:ok, {:fragmented, :end, fragment}} + ) do + GenServer.cast(parent, {fragments_type, IO.iodata_to_binary([fragments | fragment])}) + loop(%__MODULE__{state | fragments_type: nil, fragments: []}) + end + + defp loop(%__MODULE__{parent: parent} = state, {:ok, {:binary, _} = binary}) do + GenServer.cast(parent, binary) + loop(state) + end + + defp loop(%__MODULE__{parent: parent} = state, {:ok, {:text, _} = text}) do + GenServer.cast(parent, text) + loop(state) + end + + defp loop(%__MODULE__{socket_web: socket_web} = state, {:ok, {:ping, data}}) do + Socket.Web.send!(socket_web, {:pong, data}) + loop(state) + end + + defp loop(%__MODULE__{parent: parent} = state, {:ok, {:pong, _data} = pong}) do + GenServer.cast(parent, pong) + loop(state) + end + + defp loop(%__MODULE__{parent: parent}, {:ok, :close = close}) do + GenServer.cast(parent, close) + end + + defp loop(%__MODULE__{parent: parent}, {:ok, {:close, _code, _data} = close}) do + GenServer.cast(parent, close) + end + + defp loop(%__MODULE__{parent: parent}, {:error, _reason} = error) do + GenServer.cast(parent, error) + end +end diff --git a/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex.ex b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex.ex index c5b77d8acd..8049252f60 100644 --- a/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex.ex +++ b/apps/ethereum_jsonrpc/lib/ethereum_jsonrpc/web_socket/web_sockex.ex @@ -10,7 +10,7 @@ defmodule EthereumJSONRPC.WebSocket.WebSockex do import EthereumJSONRPC, only: [request: 1] alias EthereumJSONRPC.{Subscription, Transport, WebSocket} - alias EthereumJSONRPC.WebSocket.WebSockex.Registration + alias EthereumJSONRPC.WebSocket.Registration @behaviour WebSocket diff --git a/apps/ethereum_jsonrpc/mix.exs b/apps/ethereum_jsonrpc/mix.exs index 5349af3076..9f1341c66e 100644 --- a/apps/ethereum_jsonrpc/mix.exs +++ b/apps/ethereum_jsonrpc/mix.exs @@ -75,7 +75,11 @@ defmodule EthereumJsonrpc.MixProject do {:timex, "~> 3.1.24"}, # Encode/decode function names and arguments {:ex_abi, "~> 0.1.16"}, - # `EthereumJSONRPC.WebSocket.Client` + # `EthereumJSONRPC.WebSocket` + {:socket, "~> 0.3.13"}, + # `:verify_fun` for `Socket.Web.connect` + {:ssl_verify_fun, "~> 1.1"}, + # `EthereumJSONRPC.WebSocket` {:websockex, "~> 0.4.1"} ] end diff --git a/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/geth.ex b/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/geth.ex index 51bf57aec0..7f08d19a0b 100644 --- a/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/geth.ex +++ b/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/geth.ex @@ -7,7 +7,7 @@ defmodule EthereumJSONRPC.WebSocket.Case.Geth do def setup do url = "wss://mainnet.infura.io/ws/8lTvJTKmHPCHazkneJsY" - web_socket_module = EthereumJSONRPC.WebSocket.WebSockex + web_socket_module = EthereumJSONRPC.WebSocket.Socket web_socket = start_supervised!({web_socket_module, [url, []]}) %{ diff --git a/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/parity.ex b/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/parity.ex index a13afd79e5..9edd9aa012 100644 --- a/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/parity.ex +++ b/apps/ethereum_jsonrpc/test/support/ethereum_jsonrpc/web_socket/case/parity.ex @@ -7,7 +7,7 @@ defmodule EthereumJSONRPC.WebSocket.Case.Parity do def setup do url = "wss://sokol-ws.poa.network/ws" - web_socket_module = EthereumJSONRPC.WebSocket.WebSockex + web_socket_module = EthereumJSONRPC.WebSocket.Socket web_socket = start_supervised!({web_socket_module, [url, []]}) %{ diff --git a/mix.lock b/mix.lock index 4e9b56f646..bdb5c8fd9c 100644 --- a/mix.lock +++ b/mix.lock @@ -71,6 +71,7 @@ "ranch": {:hex, :ranch, "1.3.2", "e4965a144dc9fbe70e5c077c65e73c57165416a901bd02ea899cfd95aa890986", [:rebar3], []}, "set_locale": {:git, "https://github.com/minifast/set_locale.git", "da9ae029642bc0fbd9212c2aaf86c0adca70c084", [branch: "master"]}, "sobelow": {:hex, :sobelow, "0.7.0", "68ac7cb55040e8d33fb0e5df0008b4f612d2b97ea2bc99a013967a9a200ffc57", [:mix], []}, + "socket": {:hex, :socket, "0.3.13", "98a2ab20ce17f95fb512c5cadddba32b57273e0d2dba2d2e5f976c5969d0c632", [:mix], [], "hexpm"}, "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.1", "28a4d65b7f59893bc2c7de786dec1e1555bd742d336043fe644ae956c3497fbe", [:make, :rebar], []}, "timex": {:hex, :timex, "3.1.25", "6002dae5432f749d1c93e2cd103eb73cecb53e50d2c885349e8e4146fc96bd44", [:mix], [{:combine, "~> 0.10", [hex: :combine, optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, optional: false]}, {:tzdata, "~> 0.1.8 or ~> 0.5", [hex: :tzdata, optional: false]}]}, "timex_ecto": {:hex, :timex_ecto, "3.2.1", "461140751026e1ca03298fab628f78ab189e78784175f5e301eefa034ee530aa", [:mix], [{:ecto, "~> 2.2", [hex: :ecto, optional: false]}, {:timex, "~> 3.1", [hex: :timex, optional: false]}]},