From 0bf9197f415b4eec22616d593a01ec23dd1dea72 Mon Sep 17 00:00:00 2001 From: Fabricio Pashaj Date: Tue, 24 Aug 2021 19:21:24 +0300 Subject: [PATCH] net.http: add a close method to immediatly close the listener of a started http.Server, add more tests (#11248) --- examples/http_server.v | 28 +++++++++++++ vlib/net/http/server.v | 53 ++++++++++++++++++------ vlib/net/http/server_test.v | 80 +++++++++++++++++++++++++++++++++++-- 3 files changed, 145 insertions(+), 16 deletions(-) create mode 100644 examples/http_server.v diff --git a/examples/http_server.v b/examples/http_server.v new file mode 100644 index 0000000000..ffcc299dbf --- /dev/null +++ b/examples/http_server.v @@ -0,0 +1,28 @@ +module main + +import net.http { CommonHeader, Request, Response, Server } + +struct ExampleHandler {} + +fn (h ExampleHandler) handle(req Request) Response { + mut res := Response{ + header: http.new_header_from_map({ + CommonHeader.content_type: 'text/plain' + }) + } + res.text = match req.url { + '/foo' { 'bar\n' } + '/hello' { 'world\n' } + '/' { 'foo\nhello\n' } + else { 'Not found\n' } + } + res.status_code = if res.text == 'Not found' { 404 } else { 200 } + return res +} + +fn main() { + mut server := Server{ + handler: ExampleHandler{} + } + server.listen_and_serve() ? +} diff --git a/vlib/net/http/server.v b/vlib/net/http/server.v index 0194be1baf..7a9660da7a 100644 --- a/vlib/net/http/server.v +++ b/vlib/net/http/server.v @@ -7,12 +7,24 @@ import io import net import time +// ServerStatus is the current status of the server. +// .running means that the server is active and serving. +// .stopped means that the server is not active but still listening. +// .closed means that the server is completely inactive. +pub enum ServerStatus { + running + stopped + closed +} + interface Handler { handle(Request) Response } pub struct Server { - stop_signal chan bool = chan bool{cap: 1} +mut: + state ServerStatus = .closed + listener net.TcpListener pub mut: port int = 8080 handler Handler = DebugHandler{} @@ -21,22 +33,20 @@ pub mut: accept_timeout time.Duration = 30 * time.second } -pub fn (s &Server) listen_and_serve() ? { +pub fn (mut s Server) listen_and_serve() ? { if s.handler is DebugHandler { eprintln('Server handler not set, using debug handler') } - mut l := net.listen_tcp(.ip6, ':$s.port') ? - l.set_accept_timeout(s.accept_timeout) + s.listener = net.listen_tcp(.ip6, ':$s.port') ? + s.listener.set_accept_timeout(s.accept_timeout) eprintln('Listening on :$s.port') + s.state = .running for { - // break if we have a stop signal (non-blocking check) - select { - _ := <-s.stop_signal { - break - } - else {} + // break if we have a stop signal + if s.state != .running { + break } - mut conn := l.accept() or { + mut conn := s.listener.accept() or { if err.msg != 'net: op timed out' { eprintln('accept() failed: $err; skipping') } @@ -47,10 +57,27 @@ pub fn (s &Server) listen_and_serve() ? { // TODO: make concurrent s.parse_and_respond(mut conn) } + if s.state == .stopped { + s.close() + } } -pub fn (s Server) stop() { - s.stop_signal <- true +// stop signals the server that it should not respond anymore +[inline] +pub fn (mut s Server) stop() { + s.state = .stopped +} + +// close immediatly closes the port and signals the server that it has been closed +[inline] +pub fn (mut s Server) close() { + s.state = .closed + s.listener.close() or { return } +} + +[inline] +pub fn (s &Server) status() ServerStatus { + return s.state } fn (s &Server) parse_and_respond(mut conn net.TcpConn) { diff --git a/vlib/net/http/server_test.v b/vlib/net/http/server_test.v index 9a4437ced6..790da30b56 100644 --- a/vlib/net/http/server_test.v +++ b/vlib/net/http/server_test.v @@ -1,16 +1,90 @@ -module http - +import net.http import time fn test_server_stop() ? { - server := &Server{ + mut server := &http.Server{ accept_timeout: 1 * time.second } t := go server.listen_and_serve() time.sleep(250 * time.millisecond) mut watch := time.new_stopwatch() server.stop() + assert server.status() == .stopped assert watch.elapsed() < 100 * time.millisecond t.wait() ? assert watch.elapsed() < 999 * time.millisecond } + +fn test_server_close() ? { + mut server := &http.Server{ + accept_timeout: 1 * time.second + handler: MyHttpHandler{} + } + t := go server.listen_and_serve() + time.sleep(250 * time.millisecond) + mut watch := time.new_stopwatch() + server.close() + assert server.status() == .closed + assert watch.elapsed() < 100 * time.millisecond + t.wait() ? + assert watch.elapsed() < 999 * time.millisecond +} + +struct MyHttpHandler { +mut: + counter int + oks int + not_founds int +} + +fn (mut handler MyHttpHandler) handle(req http.Request) http.Response { + handler.counter++ + // eprintln('$time.now() | counter: $handler.counter | $req.method $req.url\n$req.header\n$req.data - 200 OK\n') + mut r := http.Response{ + text: req.data + ', $req.url' + header: req.header + } + match req.url.all_before('?') { + '/endpoint', '/another/endpoint' { + r.set_status(.ok) + handler.oks++ + } + else { + r.set_status(.not_found) + handler.not_founds++ + } + } + r.set_version(req.version) + return r +} + +const cport = 8198 + +fn test_server_custom_handler() ? { + mut handler := MyHttpHandler{} + mut server := &http.Server{ + accept_timeout: 1 * time.second + handler: handler + port: cport + } + t := go server.listen_and_serve() + for server.status() != .running { + time.sleep(10 * time.millisecond) + } + x := http.fetch(url: 'http://localhost:$cport/endpoint?abc=xyz', data: 'my data') ? + assert x.text == 'my data, /endpoint?abc=xyz' + assert x.status_code == 200 + assert x.http_version == '1.1' + y := http.fetch(url: 'http://localhost:$cport/another/endpoint', data: 'abcde') ? + assert y.text == 'abcde, /another/endpoint' + assert y.status_code == 200 + assert y.status() == .ok + assert y.http_version == '1.1' + // + http.fetch(url: 'http://localhost:$cport/something/else') ? + server.stop() + t.wait() ? + assert handler.counter == 3 + assert handler.oks == 2 + assert handler.not_founds == 1 +}