85 lines
2.1 KiB
Elixir
85 lines
2.1 KiB
Elixir
defmodule Excache.Test.RespClient do
|
|
@moduledoc false
|
|
|
|
def connect(port) do
|
|
{:ok, socket} =
|
|
:gen_tcp.connect(~c"127.0.0.1", port, [:binary, active: false, packet: :raw])
|
|
|
|
%{socket: socket, buffer: ""}
|
|
end
|
|
|
|
def close(%{socket: socket}), do: :gen_tcp.close(socket)
|
|
|
|
def command(conn, args) do
|
|
:ok = :gen_tcp.send(conn.socket, encode_request(args))
|
|
read(conn)
|
|
end
|
|
|
|
def send_raw(conn, bytes) do
|
|
:ok = :gen_tcp.send(conn.socket, bytes)
|
|
conn
|
|
end
|
|
|
|
def read(conn) do
|
|
{<<type, payload::binary>>, conn} = read_line(conn)
|
|
|
|
case type do
|
|
?+ -> {{:simple, payload}, conn}
|
|
?- -> {{:error, payload}, conn}
|
|
?: -> {String.to_integer(payload), conn}
|
|
?$ -> read_bulk(String.to_integer(payload), conn)
|
|
?* -> read_array(String.to_integer(payload), conn)
|
|
end
|
|
end
|
|
|
|
defp read_bulk(length, conn) when length < 0, do: {nil, conn}
|
|
|
|
defp read_bulk(length, conn) do
|
|
conn = fill(conn, length + 2)
|
|
<<data::binary-size(length), "\r\n", rest::binary>> = conn.buffer
|
|
{data, %{conn | buffer: rest}}
|
|
end
|
|
|
|
defp read_array(count, conn) when count < 0, do: {nil, conn}
|
|
|
|
defp read_array(count, conn), do: read_elements(count, conn, [])
|
|
|
|
defp read_elements(0, conn, acc), do: {Enum.reverse(acc), conn}
|
|
|
|
defp read_elements(count, conn, acc) do
|
|
{value, conn} = read(conn)
|
|
read_elements(count - 1, conn, [value | acc])
|
|
end
|
|
|
|
defp read_line(conn) do
|
|
case :binary.split(conn.buffer, "\r\n") do
|
|
[line, rest] ->
|
|
{line, %{conn | buffer: rest}}
|
|
|
|
[_only] ->
|
|
{:ok, more} = :gen_tcp.recv(conn.socket, 0, 2000)
|
|
read_line(%{conn | buffer: conn.buffer <> more})
|
|
end
|
|
end
|
|
|
|
defp fill(conn, needed) do
|
|
if byte_size(conn.buffer) >= needed do
|
|
conn
|
|
else
|
|
{:ok, more} = :gen_tcp.recv(conn.socket, 0, 2000)
|
|
fill(%{conn | buffer: conn.buffer <> more}, needed)
|
|
end
|
|
end
|
|
|
|
defp encode_request(args) do
|
|
[
|
|
"*",
|
|
Integer.to_string(length(args)),
|
|
"\r\n",
|
|
Enum.map(args, fn arg ->
|
|
["$", Integer.to_string(byte_size(arg)), "\r\n", arg, "\r\n"]
|
|
end)
|
|
]
|
|
end
|
|
end
|