@@ -1,0 +1,501 @@
# Copyright 2026 Cole Christensen
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
defmodule ExGitObjectstore.Test.GitDaemon do
@moduledoc """
Minimal `git://` daemon for integration tests.
Spins up a TCP listener on 127.0.0.1 that accepts `git://` service
handshake lines and routes each connection to either
`UploadPackV2` (for `git-upload-pack`, protocol v2) or `ReceivePack`
(for `git-receive-pack`).
Designed for test use only: each daemon serves a single repo (or a
caller-supplied `repo_fun/0` that can return different repos on each
connection, e.g. to simulate a repo being swapped behind a URL).
## Example
repo = RepoHelper.memory_repo()
{port, stop} = GitDaemon.start_upload_pack(repo)
on_exit(stop)
url = "git://127.0.0.1:" <> to_string(port) <> "/repo"
{out, code} = GitDaemon.git_clone(url, dest)
## Caveats
- Only protocol v2 is supported for upload-pack. A v0/v1 service line
causes the connection to be closed (no advertisement).
- The state machine terminates after a single command for upload-pack
(multi-round negotiation on the same TCP session will not work; the
client is expected to reconnect). This matches what HTTP-smart-style
clients do, and is the same behavior the production server exposes
in the failure modes we're targeting.
"""
alias ExGitObjectstore.Protocol.{PktLine, ReceivePack, UploadPackV2}
# --- public API ---
@doc """
Start an upload-pack (fetch/clone) daemon. `repo_or_fun` may be
an `%ExGitObjectstore.Repo{}` or a zero-arity function that returns one
(called per-connection, useful for stale-haves scenarios).
Returns `{port, stop_fn}`.
"""
def start_upload_pack(repo_or_fun) do
repo_fun = as_fun(repo_or_fun)
start_daemon(fn client -> serve_upload_pack(client, repo_fun) end)
end
@doc """
Start a receive-pack (push) daemon. `opts` is forwarded to
`ReceivePack.init/2` (so you can wire up pre_receive_hook / update_hook
/ post_receive_hook for tests that need to exercise hook behavior).
Returns `{port, stop_fn}`.
"""
def start_receive_pack(repo_or_fun, opts \\ []) do
repo_fun = as_fun(repo_or_fun)
start_daemon(fn client -> serve_receive_pack(client, repo_fun, opts) end)
end
@doc """
Start a smart-HTTP daemon that serves both upload-pack and
receive-pack for a single repo.
Routes handled (path prefix is ignored — any URL path is accepted):
* `GET */info/refs?service=git-upload-pack`
* `POST */git-upload-pack` — body fed to `UploadPackV2`
* `GET */info/refs?service=git-receive-pack`
* `POST */git-receive-pack` — body fed to `ReceivePack`
Protocol v2 is used whenever the client sends
`Git-Protocol: version=2` (git does this by default on recent versions).
Returns `{port, stop_fn}`.
"""
def start_http_smart(repo_or_fun, opts \\ []) do
repo_fun = as_fun(repo_or_fun)
start_daemon(fn client -> serve_http(client, repo_fun, opts) end)
end
@doc """
`git clone` wrapper. Returns `{output, exit_code}`.
"""
def git_clone(url, dest, extra_args \\ []) do
git_at(nil, ["-c", "protocol.version=2", "clone"] ++ extra_args ++ [url, dest])
end
@doc """
Run `git <args>` in `dir` (or no `cd` if `dir` is nil). Env defaults
suppress password prompts and disable the keyring for non-interactive
runs. Returns `{output, exit_code}`.
"""
def git_at(dir, args, extra_env \\ []) do
env = [{"GIT_TERMINAL_PROMPT", "0"} | extra_env]
opts = [stderr_to_stdout: true, env: env]
opts = if dir, do: [{:cd, dir} | opts], else: opts
System.cmd("git", args, opts)
end
@doc """
Run `git <args>` in `dir` and raise if it fails. Returns trimmed stdout.
"""
def git!(dir, args, extra_env \\ []) do
{out, code} = git_at(dir, args, extra_env)
if code != 0 do
raise """
git #{Enum.join(args, " ")} failed (exit #{code}):
#{out}
"""
end
String.trim(out)
end
@doc """
Initialize a client-side git working dir with a local identity set.
Returns the dir path.
"""
def init_client_dir(tmp_dir, name \\ "client") do
dir = Path.join(tmp_dir, name)
File.mkdir_p!(dir)
git!(dir, ["init", "--initial-branch=main"])
git!(dir, ["config", "user.email", "t@t.com"])
git!(dir, ["config", "user.name", "t"])
git!(dir, ["config", "commit.gpgsign", "false"])
dir
end
@doc """
Clone `url` into `dest_dir` and raise on failure. Returns `dest_dir`.
"""
def seed_client_clone(url, dest_dir) do
parent = Path.dirname(dest_dir)
File.mkdir_p!(parent)
{out, code} = git_clone(url, dest_dir)
if code != 0, do: raise("seed_client_clone failed (#{code}):\n#{out}")
dest_dir
end
# --- internal ---
defp as_fun(fun) when is_function(fun, 0), do: fun
defp as_fun(repo), do: fn -> repo end
defp start_daemon(handler) do
{:ok, listen} =
:gen_tcp.listen(0, [
:binary,
active: false,
reuseaddr: true,
packet: :raw,
ip: {127, 0, 0, 1}
])
{:ok, port} = :inet.port(listen)
# Unlinked: stopping the daemon (closing the listen socket) must not
# take the test process with it.
spawn(fn -> accept_loop(listen, handler) end)
stop = fn -> :gen_tcp.close(listen) end
{port, stop}
end
defp accept_loop(listen, handler) do
case :gen_tcp.accept(listen, 30_000) do
{:ok, client} ->
spawn(fn -> handler.(client) end)
accept_loop(listen, handler)
{:error, :closed} ->
:ok
{:error, _} = err ->
err
end
end
# --- upload-pack connection ---
defp serve_upload_pack(client, repo_fun) do
with {:ok, service_line} <- read_one_pkt(client),
true <- service_is?(service_line, "git-upload-pack"),
true <- v2_requested?(service_line) do
repo = repo_fun.()
{advert, state} = UploadPackV2.init(repo)
:ok = :gen_tcp.send(client, advert)
drive_upload(client, state)
else
_ -> :ok
end
after
:gen_tcp.close(client)
end
defp drive_upload(client, state) do
case :gen_tcp.recv(client, 0, 15_000) do
{:ok, data} ->
{response, new_state} = UploadPackV2.feed(state, data)
if byte_size(response) > 0, do: :ok = :gen_tcp.send(client, response)
if UploadPackV2.done?(new_state) do
:ok
else
drive_upload(client, new_state)
end
{:error, _} ->
:ok
end
end
# --- receive-pack connection ---
defp serve_receive_pack(client, repo_fun, opts) do
with {:ok, service_line} <- read_one_pkt(client),
true <- service_is?(service_line, "git-receive-pack") do
repo = repo_fun.()
{advert, state} = ReceivePack.init(repo, opts)
:ok = :gen_tcp.send(client, advert)
drive_receive(client, state)
else
_ -> :ok
end
after
:gen_tcp.close(client)
end
defp drive_receive(client, state) do
if ReceivePack.done?(state) do
:ok
else
drive_receive_recv(client, state)
end
end
defp drive_receive_recv(client, state) do
case :gen_tcp.recv(client, 0, 15_000) do
{:ok, data} -> drive_receive_feed(client, state, data)
{:error, _} -> :ok
end
end
defp drive_receive_feed(client, state, data) do
{response, new_state} = ReceivePack.feed(state, data)
if byte_size(response) > 0, do: :ok = :gen_tcp.send(client, response)
drive_receive(client, new_state)
end
# --- shared ---
defp read_one_pkt(client) do
with {:ok, <<hex::binary-size(4)>>} <- :gen_tcp.recv(client, 4, 5_000),
{len, ""} <- Integer.parse(hex, 16) do
read_pkt_payload(client, len)
else
:error -> {:error, :bad_pkt_len}
{_, _} -> {:error, :bad_pkt_len}
err -> err
end
end
defp read_pkt_payload(_client, 0), do: {:ok, ""}
defp read_pkt_payload(_client, len) when len < 4, do: {:error, :bad_pkt_len}
defp read_pkt_payload(client, len) do
:gen_tcp.recv(client, len - 4, 5_000)
end
defp service_is?(line, svc), do: String.contains?(line, svc)
defp v2_requested?(line), do: String.contains?(line, "version=2")
# --- HTTP smart-protocol handler ---
defp serve_http(client, repo_fun, opts) do
case read_http_request(client) do
{:ok, %{method: "GET", path: path, headers: headers}} ->
handle_http_get(client, path, headers, repo_fun)
{:ok, %{method: "POST", path: path, headers: headers, body: body}} ->
handle_http_post(client, path, headers, body, repo_fun, opts)
_ ->
send_http(client, 400, "text/plain", "bad request")
end
after
:gen_tcp.close(client)
end
defp handle_http_get(client, path, _headers, repo_fun) do
cond do
String.contains?(path, "service=git-upload-pack") ->
send_info_refs(client, "git-upload-pack", repo_fun.(), :upload)
String.contains?(path, "service=git-receive-pack") ->
send_info_refs(client, "git-receive-pack", repo_fun.(), :receive)
true ->
send_http(client, 404, "text/plain", "not found")
end
end
defp handle_http_post(client, path, headers, body, repo_fun, opts) do
cond do
String.ends_with?(path, "/git-upload-pack") ->
handle_upload_pack_post(client, headers, body, repo_fun)
String.ends_with?(path, "/git-receive-pack") ->
handle_receive_pack_post(client, body, repo_fun, opts)
true ->
send_http(client, 404, "text/plain", "not found")
end
end
defp send_info_refs(client, service, repo, :upload) do
{advert, _state} = UploadPackV2.init(repo)
body = service_header_line(service) <> advert
send_http(client, 200, "application/x-#{service}-advertisement", body)
end
defp send_info_refs(client, service, repo, :receive) do
{advert, _state} = ReceivePack.init(repo)
body = service_header_line(service) <> advert
send_http(client, 200, "application/x-#{service}-advertisement", body)
end
defp service_header_line(service) do
# Smart-HTTP "service=" header line per Documentation/http-protocol.txt.
PktLine.encode("# service=#{service}\n") <> PktLine.flush()
end
defp handle_upload_pack_post(client, headers, body, repo_fun) do
repo = repo_fun.()
# Upload-pack POST is always stateless per request: advertisement
# isn't expected (client already got it via info/refs), just the
# command body. Protocol v2 clients include `Git-Protocol: version=2`.
if headers["git-protocol"] && String.contains?(headers["git-protocol"], "version=2") do
{_advert, state} = UploadPackV2.init(repo)
{response, _state} = UploadPackV2.feed(state, body)
send_http(client, 200, "application/x-git-upload-pack-result", response)
else
# v0/v1 not supported by this test daemon.
send_http(client, 400, "text/plain", "only protocol v2 supported")
end
end
defp handle_receive_pack_post(client, body, repo_fun, opts) do
repo = repo_fun.()
{_advert, state} = ReceivePack.init(repo, opts)
{response, _state} = drive_receive_state(body, state)
send_http(client, 200, "application/x-git-receive-pack-result", response)
end
defp drive_receive_state(body, state) do
{first, state} = ReceivePack.feed(state, body)
if ReceivePack.done?(state) do
{first, state}
else
# Some state machines accept the pack across multiple feeds; for
# HTTP the whole body arrives at once, so a second empty feed is
# enough to let maybe_process_pack run.
{second, state} = ReceivePack.feed(state, <<>>)
{first <> second, state}
end
end
# --- HTTP/1.1 mini-parser ---
defp read_http_request(client) do
with {:ok, request_line} <- read_line(client),
[method, path, _version] <- String.split(request_line, " ", parts: 3),
{:ok, headers} <- read_headers(client, %{}) do
build_http_request(client, method, path, headers)
else
err -> {:error, err}
end
end
defp build_http_request(_client, "GET", path, headers) do
{:ok, %{method: "GET", path: path, headers: headers}}
end
defp build_http_request(client, method, path, headers) do
case read_body(client, headers) do
{:ok, body} -> {:ok, %{method: method, path: path, headers: headers, body: body}}
err -> err
end
end
defp read_line(client, acc \\ <<>>) do
case :gen_tcp.recv(client, 1, 5_000) do
{:ok, <<?\r>>} ->
case :gen_tcp.recv(client, 1, 5_000) do
{:ok, <<?\n>>} -> {:ok, acc}
_ -> {:error, :bad_line_end}
end
{:ok, <<byte>>} ->
read_line(client, acc <> <<byte>>)
{:error, _} = err ->
err
end
end
defp read_headers(client, acc) do
case read_line(client) do
{:ok, ""} ->
{:ok, acc}
{:ok, line} ->
case String.split(line, ":", parts: 2) do
[k, v] ->
read_headers(client, Map.put(acc, String.downcase(String.trim(k)), String.trim(v)))
_ ->
read_headers(client, acc)
end
err ->
err
end
end
defp read_body(client, headers) do
cond do
len = headers["content-length"] ->
n = String.to_integer(len)
if n == 0, do: {:ok, <<>>}, else: :gen_tcp.recv(client, n, 15_000)
headers["transfer-encoding"] == "chunked" ->
read_chunked(client, <<>>)
true ->
{:ok, <<>>}
end
end
defp read_chunked(client, acc) do
with {:ok, size_line} <- read_line(client),
{size, _} <- Integer.parse(size_line, 16) do
read_chunked_body(client, acc, size)
else
_ -> {:error, :bad_chunk}
end
end
defp read_chunked_body(client, acc, 0) do
# Read the trailing CRLF after the last chunk.
_ = read_line(client)
{:ok, acc}
end
defp read_chunked_body(client, acc, size) do
with {:ok, chunk} <- :gen_tcp.recv(client, size, 15_000),
{:ok, _} <- read_line(client) do
read_chunked(client, acc <> chunk)
end
end
defp send_http(client, status, content_type, body) do
status_text =
case status do
200 -> "OK"
400 -> "Bad Request"
404 -> "Not Found"
_ -> "OK"
end
headers = [
"HTTP/1.1 #{status} #{status_text}\r\n",
"Content-Type: #{content_type}\r\n",
"Content-Length: #{byte_size(body)}\r\n",
"Cache-Control: no-cache\r\n",
"Connection: close\r\n",
"\r\n"
]
:gen_tcp.send(client, [headers, body])
end
end