net.server_epoll: Add support for systemd socket activation
Allows creating listening sockets and accepting client connections
before Prosody starts.
This is unlike normal Prosody dynamic resource management, where ports
may added and removed at any time, and the ports defined by the config.
Weird things happen if these are closed (e.g. due to reload) so here we
prevent closing and ensure sockets are reused when opened again.
local http_parser = require "net.http.parser";
local sha1 = require "util.hashes".sha1;
local parser_input_bytes = 3;
local function CRLF(s)
return (s:gsub("\n", "\r\n"));
end
local function test_stream(stream, expect)
local chunks_processed = 0;
local success_cb = spy.new(function (packet)
assert.is_table(packet);
if packet.body ~= false then
assert.is_equal(expect.body, packet.body);
end
if expect.chunks then
if chunks_processed == 0 then
assert.is_true(packet.partial);
packet.body_sink = {
write = function (_, data)
chunks_processed = chunks_processed + 1;
assert.equal(expect.chunks[chunks_processed], data);
return true;
end;
};
end
end
end);
local function options_cb()
return {
-- Force streaming API mode
body_size_limit = expect.chunks and 0 or nil;
buffer_size_limit = 10*1024*2;
};
end
local parser = http_parser.new(success_cb, error, (stream[1] or stream):sub(1,4) == "HTTP" and "client" or "server", options_cb)
if type(stream) == "string" then
for chunk in stream:gmatch("."..string.rep(".?", parser_input_bytes-1)) do
parser:feed(chunk);
end
else
for _, chunk in ipairs(stream) do
parser:feed(chunk);
end
end
if expect.chunks then
assert.equal(chunks_processed, #expect.chunks);
end
assert.spy(success_cb).was_called(expect.count or 1);
end
describe("net.http.parser", function()
describe("parser", function()
it("should handle requests with no content-length or body", function ()
test_stream(
CRLF[[
GET / HTTP/1.1
Host: example.com
]],
{
body = "";
}
);
end);
it("should handle responses with empty body", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Content-Length: 0
]],
{
body = "";
}
);
end);
it("should handle simple responses", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Content-Length: 7
Hello
]],
{
body = "Hello\r\n", count = 1;
}
);
end);
it("should handle chunked encoding in responses", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Transfer-Encoding: chunked
1
H
1
e
2
ll
1
o
0
]],
{
body = "Hello", count = 3;
}
);
end);
it("should handle a stream of responses", function ()
test_stream(
CRLF[[
HTTP/1.1 200 OK
Content-Length: 5
Hello
HTTP/1.1 200 OK
Transfer-Encoding: chunked
1
H
1
e
2
ll
1
o
0
]],
{
body = "Hello", count = 4;
}
);
end);
it("should correctly find chunk boundaries", function ()
test_stream({
CRLF[[
HTTP/1.1 200 OK
Transfer-Encoding: chunked
]].."3\r\n:)\n\r\n"},
{
count = 1; -- Once (partial)
chunks = {
":)\n"
};
}
);
end);
it("should reject very large request heads", function()
local finished = false;
local success_cb = spy.new(function()
finished = true;
end)
local error_cb = spy.new(function()
finished = true;
end)
local parser = http_parser.new(success_cb, error_cb, "server", function()
return { head_size_limit = 1024; body_size_limit = 1024; buffer_size_limit = 2048 };
end)
parser:feed("GET / HTTP/1.1\r\n");
for i = 1, 64 do -- * header line > buffer_size_limit
parser:feed(string.format("Header-%04d: Yet-AnotherValue\r\n", i));
if finished then
-- should hit an error around half-way
break
end
end
if not finished then
parser:feed("\r\n")
end
assert.spy(success_cb).was_called(0);
assert.spy(error_cb).was_called(1);
assert.spy(error_cb).was_called_with("header-too-large");
end)
end);
it("should handle large chunked responses", function ()
local data = io.open("spec/inputs/http/httpstream-chunked-test.txt", "rb"):read("*a");
-- Just a sanity check... text editors and things may mess with line endings, etc.
assert.equal("25930f021785ae14053a322c2dbc1897c3769720", sha1(data, true), "test data malformed");
test_stream(data, {
body = string.rep("~", 11085), count = 3;
});
end);
end);