e5e7ebfe80dbec4965226225050d4ef5c8216e88-PR-605

Committed 21 Feb 2025 02:35PM UTC coverage: 45.973% (-0.03%) from 46.003%

Build # e5e7ebfe80dbec4965226225050d4ef5c8216e88-PR-605

Build Type

Pull #605

github

Committed by

hauleth

Commit Message

fix: remaining SSL connections that need to set `verify_none` option

Pull Request Pull Request #605: fix: remaining SSL connections that need to set `verify_none` option

Run Details

2 of 9 new or added lines in 3 files covered. (22.22%)

267 existing lines in 26 files now uncovered.

959 of 2086 relevant lines covered (45.97%)

635.02 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

20.75

/lib/supavisor/protocol/client.ex

defmodule Supavisor.Protocol.Client do
  @moduledoc false

  require Logger

  @pkt_header_size 5

  defmodule Pkt do
    @moduledoc false
    defstruct([:tag, :len, :payload, :bin])

    @type t :: %Pkt{
            tag: atom,
            len: integer,
            payload: any,
            bin: binary
          }
  end

  def pkt_header_size, do: @pkt_header_size

  def header(<<char::8, pkt_len::32>>) do
    {tag(char), pkt_len}
  end

  @spec decode(binary) :: {:ok, [Pkt.t()], binary} | {:error, any}
  def decode(data) do
    decode(data, [])
  end

  @spec decode(binary, [Pkt.t()]) :: {:ok, [Pkt.t()], binary} | {:error, any}
  def decode("", acc), do: {:ok, Enum.reverse(acc), ""}

  def decode(data, acc) do
    case decode_pkt(data) do
      {:ok, pkt, rest} -> decode(rest, [pkt | acc])
      {:error, :payload_too_small} -> {:ok, Enum.reverse(acc), data}
    end
  end

  @spec decode_pkt(binary) ::
          {:ok, Pkt.t(), binary}
          | {:acc, nil, binary}
          | {:error, :payload_too_small}
  def decode_pkt(<<_::8, pkt_len::32, payload::binary>>)
      when byte_size(payload) < pkt_len - 4 do
    {:error, :payload_too_small}
  end

  def decode_pkt(<<char::8, pkt_len::32, rest::binary>>) do
    case tag(char) do
      nil ->
        {:error, {:undefined_tag, <<char>>}}

      tag ->
        payload_len = pkt_len - 4
        <<bin_payload::binary-size(payload_len), rest2::binary>> = rest

        {:ok,
         %Pkt{
           tag: tag,
           len: pkt_len + 1,
           payload: decode_payload(tag, bin_payload),
           bin: <<char, pkt_len::32, bin_payload::binary>>
         }, rest2}
    end
  end

  def decode_pkt(_), do: {:error, :header_mismatch}

  @spec get_payload(binary | any()) :: {:ok, String.t()} | {:error, any}
  def get_payload(<<char::8, pkt_len::32, rest::binary>>) do
    case tag(char) do
      nil ->
        {:error, {:undefined_tag, <<char>>}}

      tag ->
        try do
          payload_len = pkt_len - 4
          <<bin_payload::binary-size(payload_len), _::binary>> = rest

          {:ok, decode_payload(tag, bin_payload)}
        rescue
          reason ->
            {:error, {:decode_payload_error, reason}}
        end
    end
  end

  def get_payload(msg), do: {:error, {:invalid_msg, msg}}

  @spec tag(byte) :: atom | nil
  def tag(char) do
    case char do
      ?Q -> :simple_query
      ?H -> :flush_message
      ?P -> :parse_message
      ?B -> :bind_message
      ?D -> :describe_message
      ?E -> :execute_message
      ?S -> :sync_message
      ?X -> :termination_message
      ?C -> :close_message
      _ -> nil
    end
  end

  def decode_payload(:simple_query, payload) do
    case :binary.split(payload, <<0>>) do
      [query, ""] -> query
      _ -> :undefined
    end
  end

  def decode_payload(:parse_message, <<0>>), do: :undefined

  def decode_payload(:parse_message, payload) do
    case :binary.split(payload, <<0>>, [:global, :trim_all]) do
      [sql] -> sql
      message -> message
    end
  end

  def decode_payload(:describe_message, <<char::binary-size(1), str_name::binary>>) do
    str_name = String.trim_trailing(str_name, <<0>>)
    %{char: char, str_name: str_name}
  end

  def decode_payload(:close_message, <<char::binary-size(1), str_name::binary>>) do
    str_name = String.trim_trailing(str_name, <<0>>)
    %{char: char, str_name: str_name}
  end

  def decode_payload(:flush_message, <<4::32>>), do: nil

  def decode_payload(:termination_message, _payload), do: nil

  def decode_payload(:bind_message, _payload), do: nil

  def decode_payload(:execute_message, _payload), do: nil

  def decode_payload(_tag, ""), do: nil

  def decode_payload(_tag, payload) do
    Logger.error("undefined payload: #{inspect(payload)}")
    :undefined
  end

  def decode_startup_packet(<<len::32, _protocol::binary-4, rest::binary>>) do
    # <<major::16, minor::16>> = protocol

    %Pkt{
      len: len,
      payload:
        String.split(rest, <<0>>, trim: true)
        |> Enum.chunk_every(2)
        |> Enum.into(%{}, fn [k, v] -> {k, v} end),
      tag: :startup
    }
  end

  def decode_startup_packet(_) do
    :undef
  end

  def parse_msg_sel_1 do
    <<80, 0, 0, 0, 16, 0, 115, 101, 108, 101, 99, 116, 32, 49, 0, 0, 0, 66, 0, 0, 0, 12, 0, 0, 0,
      0, 0, 0, 0, 0, 68, 0, 0, 0, 6, 80, 0, 69, 0, 0, 0, 9, 0, 0, 0, 0, 200, 83, 0, 0, 0, 4>>
  end
end

1	defmodule Supavisor.Protocol.Client do
2	@moduledoc false
3
4	require Logger
5
6	@pkt_header_size 5
7
8	defmodule Pkt do
9	@moduledoc false
10	defstruct([:tag, :len, :payload, :bin])
11
12	@type t :: %Pkt{
13	tag: atom,
14	len: integer,
15	payload: any,
16	bin: binary
17	}
18	end
19
20	def pkt_header_size, do: @pkt_header_size	×
21
22	def header(<<char::8, pkt_len::32>>) do	×
23	{tag(char), pkt_len}
24	end
25
26	@spec decode(binary) :: {:ok, [Pkt.t()], binary} \| {:error, any}
27	def decode(data) do
28	decode(data, [])	×
29	end
30
31	@spec decode(binary, [Pkt.t()]) :: {:ok, [Pkt.t()], binary} \| {:error, any}
32	def decode("", acc), do: {:ok, Enum.reverse(acc), ""}	×
33
34	def decode(data, acc) do
35	case decode_pkt(data) do	×
36	{:ok, pkt, rest} -> decode(rest, [pkt \| acc])	×
37	{:error, :payload_too_small} -> {:ok, Enum.reverse(acc), data}	×
38	end
39	end
40
41	@spec decode_pkt(binary) ::
42	{:ok, Pkt.t(), binary}
43	\| {:acc, nil, binary}
44	\| {:error, :payload_too_small}
45	def decode_pkt(<<_::8, pkt_len::32, payload::binary>>)	×
46	when byte_size(payload) < pkt_len - 4 do
47	{:error, :payload_too_small}
48	end
49
50	def decode_pkt(<<char::8, pkt_len::32, rest::binary>>) do
51	case tag(char) do	×
52	nil ->	×
53	{:error, {:undefined_tag, <<char>>}}
54
55	tag ->
56	payload_len = pkt_len - 4	×
57	<<bin_payload::binary-size(payload_len), rest2::binary>> = rest	×
58
59	{:ok,	×
60	%Pkt{
61	tag: tag,
62	len: pkt_len + 1,
63	payload: decode_payload(tag, bin_payload),
64	bin: <<char, pkt_len::32, bin_payload::binary>>
65	}, rest2}
66	end
67	end
68
69	def decode_pkt(_), do: {:error, :header_mismatch}	×
70
71	@spec get_payload(binary \| any()) :: {:ok, String.t()} \| {:error, any}
72	def get_payload(<<char::8, pkt_len::32, rest::binary>>) do
UNCOV 73	case tag(char) do	15✔
74	nil ->	×
75	{:error, {:undefined_tag, <<char>>}}
76
77	tag ->
UNCOV 78	try do	15✔
UNCOV 79	payload_len = pkt_len - 4	15✔
UNCOV 80	<<bin_payload::binary-size(payload_len), _::binary>> = rest	15✔
81
82	{:ok, decode_payload(tag, bin_payload)}
83	rescue
84	reason ->	×
85	{:error, {:decode_payload_error, reason}}
86	end
87	end
88	end
89
90	def get_payload(msg), do: {:error, {:invalid_msg, msg}}	×
91
92	@spec tag(byte) :: atom \| nil
93	def tag(char) do
UNCOV 94	case char do	15✔
UNCOV 95	?Q -> :simple_query	8✔
96	?H -> :flush_message	×
UNCOV 97	?P -> :parse_message	7✔
98	?B -> :bind_message	×
99	?D -> :describe_message	×
100	?E -> :execute_message	×
101	?S -> :sync_message	×
102	?X -> :termination_message	×
103	?C -> :close_message	×
104	_ -> nil	×
105	end
106	end
107
108	def decode_payload(:simple_query, payload) do
UNCOV 109	case :binary.split(payload, <<0>>) do	8✔
UNCOV 110	[query, ""] -> query	8✔
111	_ -> :undefined	×
112	end
113	end
114
115	def decode_payload(:parse_message, <<0>>), do: :undefined	×
116
117	def decode_payload(:parse_message, payload) do
UNCOV 118	case :binary.split(payload, <<0>>, [:global, :trim_all]) do	7✔
UNCOV 119	[sql] -> sql	7✔
120	message -> message	×
121	end
122	end
123
124	def decode_payload(:describe_message, <<char::binary-size(1), str_name::binary>>) do
125	str_name = String.trim_trailing(str_name, <<0>>)	×
126	%{char: char, str_name: str_name}	×
127	end
128
129	def decode_payload(:close_message, <<char::binary-size(1), str_name::binary>>) do
130	str_name = String.trim_trailing(str_name, <<0>>)	×
131	%{char: char, str_name: str_name}	×
132	end
133
134	def decode_payload(:flush_message, <<4::32>>), do: nil	×
135
136	def decode_payload(:termination_message, _payload), do: nil	×
137
138	def decode_payload(:bind_message, _payload), do: nil	×
139
140	def decode_payload(:execute_message, _payload), do: nil	×
141
142	def decode_payload(_tag, ""), do: nil	×
143
144	def decode_payload(_tag, payload) do
145	Logger.error("undefined payload: #{inspect(payload)}")	×
146	:undefined
147	end
148
149	def decode_startup_packet(<<len::32, _protocol::binary-4, rest::binary>>) do
150	# <<major::16, minor::16>> = protocol
151
152	%Pkt{	×
153	len: len,
154	payload:
155	String.split(rest, <<0>>, trim: true)
156	\|> Enum.chunk_every(2)
157	\|> Enum.into(%{}, fn [k, v] -> {k, v} end),	×
158	tag: :startup
159	}
160	end
161
162	def decode_startup_packet(_) do	×
163	:undef
164	end
165
166	def parse_msg_sel_1 do
167	<<80, 0, 0, 0, 16, 0, 115, 101, 108, 101, 99, 116, 32, 49, 0, 0, 0, 66, 0, 0, 0, 12, 0, 0, 0,	×
168	0, 0, 0, 0, 0, 68, 0, 0, 0, 6, 80, 0, 69, 0, 0, 0, 9, 0, 0, 0, 0, 200, 83, 0, 0, 0, 4>>
169	end
170	end

supabase / supavisor / e5e7ebfe80dbec4965226225050d4ef5c8216e88-PR-605

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous