();
64 | router.route("/").process(
65 | [](const asyncgi::Request&, asyncgi::Responder& response, RouteContext& context)
66 | {
67 | if (context.role == AccessRole::Admin)
68 | response.send("Hello admin
");
69 | else
70 | response.send(R"(Hello guest
login)");
71 | });
72 |
73 | router.route("/login", http::RequestMethod::Get).process();
74 | router.route("/login", http::RequestMethod::Post).process();
75 | router.route().set(http::ResponseStatus::_404_Not_Found, "Page not found");
76 |
77 | auto server = asyncgi::Server{io, router};
78 | #ifndef _WIN32
79 | server.listen("/tmp/fcgi.sock");
80 | #else
81 | server.listen("127.0.0.1", 9088);
82 | #endif
83 | io.run();
84 | return 0;
85 | }
--------------------------------------------------------------------------------
/examples/example_route_matcher.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | namespace http = asyncgi::http;
6 | using namespace std::string_literals;
7 |
8 | enum class AccessRole {
9 | Admin,
10 | Guest
11 | };
12 |
13 | struct RouteContext {
14 | AccessRole role = AccessRole::Guest;
15 | };
16 |
17 | struct AdminAuthorizer {
18 | std::optional operator()(const asyncgi::Request& request, RouteContext& context)
19 | {
20 | if (request.cookie("admin_id") == "ADMIN_SECRET")
21 | context.role = AccessRole::Admin;
22 |
23 | return std::nullopt;
24 | }
25 | };
26 |
27 | struct LoginPage {
28 | http::Response operator()(const asyncgi::Request&)
29 | {
30 | return {R"(
31 |
32 | )"};
39 | }
40 | };
41 |
42 | struct LoginPageAuthorize {
43 | http::Response operator()(const asyncgi::Request& request)
44 | {
45 | if (request.formField("login") == "admin" && request.formField("passwd") == "12345")
46 | return {http::Redirect{"/"}, {asyncgi::http::Cookie("admin_id", "ADMIN_SECRET")}};
47 |
48 | return http::Redirect{"/login"};
49 | }
50 | };
51 |
52 | template<>
53 | struct asyncgi::config::RouteMatcher {
54 | bool operator()(AccessRole value, const asyncgi::Request&, const RouteContext& context) const
55 | {
56 | return value == context.role;
57 | }
58 | };
59 |
60 | int main()
61 | {
62 | auto io = asyncgi::IO{4};
63 | auto router = asyncgi::Router{io};
64 | router.route(asyncgi::rx{".*"}).process();
65 | router.route("/").process(
66 | [](const asyncgi::Request&, RouteContext& context) -> http::Response
67 | {
68 | if (context.role == AccessRole::Admin)
69 | return {"Hello admin
"};
70 | else
71 | return {R"(Hello guest
login)"};
72 | });
73 |
74 | router.route("/login", http::RequestMethod::Get, AccessRole::Guest).process();
75 | router.route("/login", http::RequestMethod::Post, AccessRole::Guest).process();
76 | router.route("/login", http::RequestMethod::Get, AccessRole::Admin).set("/", http::RedirectType::Found);
77 | router.route("/login", http::RequestMethod::Post, AccessRole::Admin).set("/", http::RedirectType::Found);
78 | router.route().set(http::ResponseStatus::_404_Not_Found, "Page not found");
79 |
80 | auto server = asyncgi::Server{io, router};
81 | #ifndef _WIN32
82 | server.listen("/tmp/fcgi.sock");
83 | #else
84 | server.listen("127.0.0.1", 9088);
85 | #endif
86 | io.run();
87 | return 0;
88 | }
--------------------------------------------------------------------------------
/examples/example_route_params.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | using namespace asyncgi;
5 | using namespace std::string_literals;
6 |
7 | class GuestBookState {
8 | public:
9 | std::vector messages()
10 | {
11 | auto lock = std::scoped_lock{mutex_};
12 | return messages_;
13 | }
14 |
15 | void addMessage(const std::string& msg)
16 | {
17 | auto lock = std::scoped_lock{mutex_};
18 | messages_.emplace_back(msg);
19 | }
20 |
21 | void removeMessage(int index)
22 | {
23 | auto lock = std::scoped_lock{mutex_};
24 | if (index < 0 || index >= static_cast(messages_.size()))
25 | return;
26 | messages_.erase(std::next(messages_.begin(), index));
27 | }
28 |
29 | private:
30 | std::vector messages_;
31 | std::mutex mutex_;
32 | };
33 |
34 | std::string makeMessage(int index, const std::string& msg)
35 | {
36 | return msg + R"()";
38 | }
39 |
40 | class GuestBookPage {
41 | public:
42 | explicit GuestBookPage(GuestBookState& state)
43 | : state_{&state}
44 | {
45 | }
46 |
47 | http::Response operator()(const asyncgi::Request&)
48 | {
49 | auto messages = state_->messages();
50 | auto page = "Guest book
"s;
51 | if (messages.empty())
52 | page += "No messages
";
53 | else
54 | for (auto i = 0; i < static_cast(messages.size()); ++i)
55 | page += "" + makeMessage(i, messages.at(i)) + "
";
56 |
57 | page += "
";
58 | page += "";
63 | return page;
64 | }
65 |
66 | private:
67 | GuestBookState* state_;
68 | };
69 |
70 | class GuestBookAddMessage {
71 | public:
72 | explicit GuestBookAddMessage(GuestBookState& state)
73 | : state_{&state}
74 | {
75 | }
76 |
77 | http::Response operator()(const asyncgi::Request& request)
78 | {
79 | state_->addMessage(std::string{request.formField("msg")});
80 | return http::Redirect{"/"};
81 | }
82 |
83 | private:
84 | GuestBookState* state_;
85 | };
86 |
87 | class GuestBookRemoveMessage {
88 | public:
89 | explicit GuestBookRemoveMessage(GuestBookState& state)
90 | : state_{&state}
91 | {
92 | }
93 |
94 | http::Response operator()(int index, const asyncgi::Request&)
95 | {
96 | state_->removeMessage(index);
97 | return http::Redirect{"/"};
98 | }
99 |
100 | private:
101 | GuestBookState* state_;
102 | };
103 |
104 | int main()
105 | {
106 | auto io = asyncgi::IO{4};
107 | auto state = GuestBookState{};
108 | auto router = asyncgi::Router{io};
109 | router.route("/", http::RequestMethod::Get).process(state);
110 | router.route("/", http::RequestMethod::Post).process(state);
111 | router.route(asyncgi::rx{"/delete/(.+)"}, http::RequestMethod::Post).process(state);
112 | router.route().set(http::ResponseStatus::_404_Not_Found, "Page not found");
113 |
114 | auto server = asyncgi::Server{io, router};
115 | #ifndef _WIN32
116 | server.listen("/tmp/fcgi.sock");
117 | #else
118 | server.listen("127.0.0.1", 9088);
119 | #endif
120 | io.run();
121 | return 0;
122 | }
--------------------------------------------------------------------------------
/examples/example_route_params_user_defined_types.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | using namespace asyncgi;
5 | using namespace std::string_literals;
6 |
7 | struct MessageNumber {
8 | int value;
9 | };
10 |
11 | template<>
12 | struct asyncgi::config::StringConverter {
13 | static std::optional fromString(const std::string& data)
14 | {
15 | return MessageNumber{std::stoi(data)};
16 | }
17 | };
18 |
19 | class GuestBookState {
20 | public:
21 | std::vector messages()
22 | {
23 | auto lock = std::scoped_lock{mutex_};
24 | return messages_;
25 | }
26 |
27 | void addMessage(const std::string& msg)
28 | {
29 | auto lock = std::scoped_lock{mutex_};
30 | messages_.emplace_back(msg);
31 | }
32 |
33 | void removeMessage(int index)
34 | {
35 | auto lock = std::scoped_lock{mutex_};
36 | if (index < 0 || index >= static_cast(messages_.size()))
37 | return;
38 | messages_.erase(std::next(messages_.begin(), index));
39 | }
40 |
41 | private:
42 | std::vector messages_;
43 | std::mutex mutex_;
44 | };
45 |
46 | std::string makeMessage(int index, const std::string& msg)
47 | {
48 | return msg + R"()";
50 | }
51 |
52 | class GuestBookPage {
53 | public:
54 | explicit GuestBookPage(GuestBookState& state)
55 | : state_{&state}
56 | {
57 | }
58 |
59 | http::Response operator()(const asyncgi::Request&)
60 | {
61 | auto messages = state_->messages();
62 | auto page = "Guest book
"s;
63 | if (messages.empty())
64 | page += "No messages
";
65 | else
66 | for (auto i = 0; i < static_cast(messages.size()); ++i)
67 | page += "" + makeMessage(i, messages.at(i)) + "
";
68 |
69 | page += "
";
70 | page += "";
75 | return page;
76 | }
77 |
78 | private:
79 | GuestBookState* state_;
80 | };
81 |
82 | class GuestBookAddMessage {
83 | public:
84 | explicit GuestBookAddMessage(GuestBookState& state)
85 | : state_{&state}
86 | {
87 | }
88 |
89 | http::Response operator()(const asyncgi::Request& request)
90 | {
91 | state_->addMessage(std::string{request.formField("msg")});
92 | return http::Redirect{"/"};
93 | }
94 |
95 | private:
96 | GuestBookState* state_;
97 | };
98 |
99 | class GuestBookRemoveMessage {
100 | public:
101 | explicit GuestBookRemoveMessage(GuestBookState& state)
102 | : state_{&state}
103 | {
104 | }
105 |
106 | http::Response operator()(MessageNumber msgNumber, const asyncgi::Request&)
107 | {
108 | state_->removeMessage(msgNumber.value);
109 | return http::Redirect{"/"};
110 | }
111 |
112 | private:
113 | GuestBookState* state_;
114 | };
115 |
116 | int main()
117 | {
118 | auto io = asyncgi::IO{4};
119 | auto state = GuestBookState{};
120 | auto router = asyncgi::Router{io};
121 | router.route("/", http::RequestMethod::Get).process(state);
122 | router.route("/", http::RequestMethod::Post).process(state);
123 | router.route(asyncgi::rx{"/delete/(.+)"}, http::RequestMethod::Post).process(state);
124 | router.route().set(http::ResponseStatus::_404_Not_Found, "Page not found");
125 |
126 | auto server = asyncgi::Server{io, router};
127 | #ifndef _WIN32
128 | server.listen("/tmp/fcgi.sock");
129 | #else
130 | server.listen("127.0.0.1", 9088);
131 | #endif
132 | io.run();
133 | return 0;
134 | }
--------------------------------------------------------------------------------
/examples/example_router.cpp:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | namespace http = asyncgi::http;
5 | using namespace std::string_literals;
6 |
7 | class GuestBookState {
8 | public:
9 | std::vector messages()
10 | {
11 | auto lock = std::scoped_lock{mutex_};
12 | return messages_;
13 | }
14 |
15 | void addMessage(const std::string& msg)
16 | {
17 | auto lock = std::scoped_lock{mutex_};
18 | messages_.emplace_back(msg);
19 | }
20 |
21 | private:
22 | std::vector messages_;
23 | std::mutex mutex_;
24 | };
25 |
26 | class GuestBookPage {
27 | public:
28 | GuestBookPage(GuestBookState& state)
29 | : state_(&state)
30 | {
31 | }
32 |
33 | http::Response operator()(const asyncgi::Request&)
34 | {
35 | auto messages = state_->messages();
36 | auto page = "Guest book
"s;
37 | if (messages.empty())
38 | page += "No messages
";
39 | else
40 | for (const auto& msg : messages)
41 | page += "" + msg + "
";
42 |
43 | page += "
";
44 | page += "";
49 | return page;
50 | }
51 |
52 | private:
53 | GuestBookState* state_;
54 | };
55 |
56 | class GuestBookAddMessage {
57 | public:
58 | GuestBookAddMessage(GuestBookState& state)
59 | : state_(&state)
60 | {
61 | }
62 |
63 | http::Response operator()(const asyncgi::Request& request)
64 | {
65 | state_->addMessage(std::string{request.formField("msg")});
66 | return http::Redirect{"/"};
67 | }
68 |
69 | private:
70 | GuestBookState* state_;
71 | };
72 |
73 | int main()
74 | {
75 | auto io = asyncgi::IO{4}; //4 threads processing requests
76 | auto state = GuestBookState{};
77 | auto router = asyncgi::Router{io};
78 | router.route("/", http::RequestMethod::Get).process(state);
79 | router.route("/", http::RequestMethod::Post).process(state);
80 | router.route().set(http::Response{http::ResponseStatus::_404_Not_Found, "Page not found"});
81 | //Alternatively, it's possible to pass arguments for creation of http::Response object to the set() method.
82 | //router.route().set(http::ResponseStatus::Code_404_Not_Found, "Page not found");
83 |
84 | auto server = asyncgi::Server{io, router};
85 | #ifndef _WIN32
86 | server.listen("/tmp/fcgi.sock");
87 | #else
88 | server.listen("127.0.0.1", 9088);
89 | #endif
90 | io.run();
91 | return 0;
92 | }
--------------------------------------------------------------------------------
/examples/example_timer.cpp:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | namespace http = asyncgi::http;
4 |
5 | struct Greeter{
6 | Greeter(const int& secondsCounter)
7 | : secondsCounter_{&secondsCounter}
8 | {
9 | }
10 |
11 | http::Response operator()(const asyncgi::Request&)
12 | {
13 | return "Hello world\n(alive for " + std::to_string(*secondsCounter_) + " seconds)";
14 | }
15 |
16 | private:
17 | const int* secondsCounter_;
18 | };
19 |
20 | int main()
21 | {
22 | auto io = asyncgi::IO{};
23 | int secondsCounter = 0;
24 |
25 | auto timer = asyncgi::Timer{io};
26 | timer.startPeriodic(
27 | std::chrono::seconds(1),
28 | [&secondsCounter]()
29 | {
30 | ++secondsCounter;
31 | });
32 |
33 | auto router = asyncgi::Router{io};
34 | router.route("/").process(secondsCounter);
35 | router.route().set(http::ResponseStatus::_404_Not_Found);
36 |
37 | auto server = asyncgi::Server{io, router};
38 | #ifndef _WIN32
39 | server.listen("/tmp/fcgi.sock");
40 | #else
41 | server.listen("127.0.0.1", 9088);
42 | #endif
43 | io.run();
44 | return 0;
45 | }
--------------------------------------------------------------------------------
/external/asio:
--------------------------------------------------------------------------------
1 | set(THREADS_PREFER_PTHREAD_FLAG ON)
2 | find_package(Threads REQUIRED)
3 |
4 | include(FetchContent)
5 | Set(FETCHCONTENT_QUIET FALSE)
6 |
7 | if (NOT TARGET asio)
8 | FetchContent_Declare(asio
9 | GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
10 | GIT_TAG asio-1-24-0
11 | GIT_SHALLOW ON
12 | GIT_PROGRESS TRUE
13 | CONFIGURE_COMMAND ""
14 | BUILD_COMMAND ""
15 | )
16 |
17 | FetchContent_GetProperties(asio)
18 | if(NOT asio_POPULATED)
19 | FetchContent_Populate(asio)
20 | endif()
21 |
22 | add_library(asio INTERFACE)
23 | target_include_directories(asio INTERFACE ${asio_SOURCE_DIR}/asio/include)
24 | target_link_libraries(asio INTERFACE Threads::Threads)
25 | endif()
--------------------------------------------------------------------------------
/external/seal_lake:
--------------------------------------------------------------------------------
1 | include(FetchContent)
2 | set(SEAL_LAKE_VERSION v0.2.0)
3 | set(FETCHCONTENT_QUIET FALSE)
4 | FetchContent_Declare(seal_lake_${SEAL_LAKE_VERSION}
5 | SOURCE_DIR seal_lake_${SEAL_LAKE_VERSION}
6 | GIT_REPOSITORY "https://github.com/kamchatka-volcano/seal_lake.git"
7 | GIT_TAG ${SEAL_LAKE_VERSION}
8 | )
9 | FetchContent_MakeAvailable(seal_lake_${SEAL_LAKE_VERSION})
10 | include(${seal_lake_${SEAL_LAKE_VERSION}_SOURCE_DIR}/seal_lake.cmake)
--------------------------------------------------------------------------------
/functional_tests/asio_dispatcher/test.toast:
--------------------------------------------------------------------------------
1 | -Launch: ../../build/examples/example_asio_dispatcher
2 | -Expect output:
3 | Hello world
4 |
5 | ---
--------------------------------------------------------------------------------
/functional_tests/client/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_hello_world
2 | -Wait: 1 sec
3 | -Launch: ../../build/examples/example_client
4 | -Expect output:
5 | Hello world
6 |
7 | ---
8 |
--------------------------------------------------------------------------------
/functional_tests/client_in_processor/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_hello_world
2 | -Launch detached: ../../build/examples/example_client_in_processor
3 | -Wait: 1 sec
4 |
5 | -Expect response from "/" on port 8089:
6 | Hello world
7 | ---
8 |
9 | -Expect status from "/foo" on port 8089: 404
--------------------------------------------------------------------------------
/functional_tests/exception_in_request_handler/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/test_examples/test_exception_in_request_handler
2 | -Wait: 1 sec
3 |
4 | -Expect status from "/": 500
5 | -Expect status from "/foo": 404
--------------------------------------------------------------------------------
/functional_tests/fastcgi_params:
--------------------------------------------------------------------------------
1 |
2 | fastcgi_param QUERY_STRING $query_string;
3 | fastcgi_param REQUEST_METHOD $request_method;
4 | fastcgi_param CONTENT_TYPE $content_type;
5 | fastcgi_param CONTENT_LENGTH $content_length;
6 |
7 | fastcgi_param SCRIPT_NAME $fastcgi_script_name;
8 | fastcgi_param REQUEST_URI $request_uri;
9 | fastcgi_param DOCUMENT_URI $document_uri;
10 | fastcgi_param DOCUMENT_ROOT $document_root;
11 | fastcgi_param SERVER_PROTOCOL $server_protocol;
12 | fastcgi_param REQUEST_SCHEME $scheme;
13 | fastcgi_param HTTPS $https if_not_empty;
14 |
15 | fastcgi_param GATEWAY_INTERFACE CGI/1.1;
16 | fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;
17 |
18 | fastcgi_param REMOTE_ADDR $remote_addr;
19 | fastcgi_param REMOTE_PORT $remote_port;
20 | fastcgi_param SERVER_ADDR $server_addr;
21 | fastcgi_param SERVER_PORT $server_port;
22 | fastcgi_param SERVER_NAME $server_name;
23 |
24 | # PHP only, required if PHP was built with --enable-force-cgi-redirect
25 | fastcgi_param REDIRECT_STATUS 200;
26 |
--------------------------------------------------------------------------------
/functional_tests/hello_world/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_hello_world
2 | -Wait: 1 sec
3 |
4 | -Expect response from "/":
5 | Hello world
6 | ---
7 |
8 | -Expect status from "/foo": 404
--------------------------------------------------------------------------------
/functional_tests/lunchtoast.cfg:
--------------------------------------------------------------------------------
1 | #actions:
2 | ###
3 | format = Expect response from "%1"
4 | command = `curl -b cookies.txt --silent http://localhost:8088%1 | awk '{$1=$1};NF' | grep "\S" | head -c -1`
5 | checkOutput = %input
6 | ###
7 | format = Expect status from "%1"
8 | command = `curl -c cookies.txt --silent -i http://localhost:8088%1 | head -n 1 | cut -d ' ' -f 2 | head -c -1`
9 | checkOutput = %input
10 | ###
11 | format = Expect response from "%1" on port %2
12 | command = `curl -b cookies.txt --silent http://localhost:%2%1 | awk '{$1=$1};NF' | grep "\S" | head -c -1`
13 | checkOutput = %input
14 | ###
15 | format = Expect status from "%1" on port %2
16 | command = `curl -c cookies.txt --silent -i http://localhost:%2%1 | head -n 1 | cut -d ' ' -f 2 | head -c -1`
17 | checkOutput = %input
18 | ###
19 | format = Expect status from post request "%1"
20 | command = `curl -c cookies.txt --silent -i -X POST http://localhost:8088%1 | head -n 1 | cut -d ' ' -f 2 | head -c -1`
21 | checkOutput = %input
22 | ###
23 | format = Expect status from "%1" with form param "%2"
24 | command = `curl -c cookies.txt --silent -i -F "%2" http://localhost:8088%1 | head -n 1 | cut -d ' ' -f 2 | head -c -1`
25 | checkOutput = %input
26 | ###
27 | format = Expect status from "%1" with form param "%2" and form param "%3"
28 | command = `curl -c cookies.txt --silent -i -F "%2" -F "%3" http://localhost:8088%1 | head -n 1 | cut -d ' ' -f 2 | head -c -1`
29 | checkOutput = %input
30 | ###
31 | format = Expect cookies
32 | command = cat cookies.txt | head -c -1
33 | checkOutput = %input
34 |
--------------------------------------------------------------------------------
/functional_tests/nginx_linux.conf:
--------------------------------------------------------------------------------
1 | #user nobody;
2 | worker_processes 1;
3 | error_log error.log;
4 | error_log error.log notice;
5 | error_log error.log info;
6 | pid nginx.pid;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 |
13 | http {
14 | default_type application/octet-stream;
15 | sendfile on;
16 | #tcp_nopush on;
17 |
18 | #keepalive_timeout 0;
19 | keepalive_timeout 65;
20 |
21 | server {
22 | listen 8088;
23 | server_name localhost;
24 | index /~;
25 | location / {
26 | try_files $uri $uri/ @fcgi;
27 | }
28 | access_log access.log;
29 |
30 | location @fcgi {
31 | fastcgi_pass unix:/tmp/fcgi.sock;
32 | #or using a TCP socket
33 | #fastcgi_pass localhost:9000;
34 | include fastcgi_params;
35 | fastcgi_keep_conn off;
36 | }
37 | }
38 |
39 | server {
40 | listen 8089;
41 | server_name localhost;
42 | index /~;
43 | location / {
44 | try_files $uri $uri/ @fcgi;
45 | }
46 | access_log access.log;
47 |
48 | location @fcgi {
49 | fastcgi_pass unix:/tmp/fcgi_client.sock;
50 | #or using a TCP socket
51 | #fastcgi_pass localhost:9000;
52 | include fastcgi_params;
53 | fastcgi_keep_conn off;
54 | }
55 | }
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/functional_tests/nginx_windows.conf:
--------------------------------------------------------------------------------
1 | #user nobody;
2 | worker_processes 1;
3 | error_log error.log;
4 | error_log error.log notice;
5 | error_log error.log info;
6 | pid nginx.pid;
7 |
8 | events {
9 | worker_connections 1024;
10 | }
11 |
12 |
13 | http {
14 | default_type application/octet-stream;
15 | sendfile on;
16 | #tcp_nopush on;
17 |
18 | #keepalive_timeout 0;
19 | keepalive_timeout 65;
20 |
21 | server {
22 | listen 8088;
23 | server_name localhost;
24 | index /~;
25 | location / {
26 | try_files $uri $uri/ @fcgi;
27 | }
28 | access_log access.log;
29 |
30 | location @fcgi {
31 | fastcgi_pass localhost:9088;
32 | include fastcgi_params;
33 | fastcgi_keep_conn off;
34 | }
35 | }
36 |
37 | server {
38 | listen 8089;
39 | server_name localhost;
40 | index /~;
41 | location / {
42 | try_files $uri $uri/ @fcgi;
43 | }
44 | access_log access.log;
45 |
46 | location @fcgi {
47 | fastcgi_pass localhost:9089;
48 | include fastcgi_params;
49 | fastcgi_keep_conn off;
50 | }
51 | }
52 |
53 | }
54 |
--------------------------------------------------------------------------------
/functional_tests/request_processor/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_request_processor
2 | -Wait: 1 sec
3 |
4 | -Expect response from "/":
5 | Guest book
6 | No messages
7 | ---
8 |
9 | -Expect status from "/foo": 404
--------------------------------------------------------------------------------
/functional_tests/response_dispatching_asio_task/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_response_dispatching_asio_task
2 | -Wait: 1 sec
3 |
4 | -Expect response from "/":
5 | Hello world
6 | ---
7 |
8 | -Expect status from "/foo": 404
--------------------------------------------------------------------------------
/functional_tests/response_wait_future/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_response_wait_future
2 | -Wait: 1 sec
3 |
4 | -Expect response from "/":
5 | Hello world
6 | ---
7 |
8 | -Expect status from "/foo": 404
--------------------------------------------------------------------------------
/functional_tests/route_context/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_route_context
2 | -Wait: 1 sec
3 |
4 | -Expect status from "/foo": 404
5 |
6 | -Expect response from "/":
7 | Hello guest
login
8 | ---
9 |
10 | -Expect status from "/login" with form param "login=admin" and form param "passwd=12345": 302
11 | -Expect cookies:
12 | # Netscape HTTP Cookie File
13 | # https://curl.se/docs/http-cookies.html
14 | # This file was generated by libcurl! Edit at your own risk.
15 |
16 | localhost FALSE / FALSE 0 admin_id ADMIN_SECRET
17 | ---
18 |
19 | -Expect response from "/":
20 |
Hello admin
21 | ---
--------------------------------------------------------------------------------
/functional_tests/route_matchers/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_route_matcher
2 | -Wait: 1 sec
3 |
4 | -Expect status from "/foo": 404
5 |
6 | -Expect response from "/":
7 | Hello guest
login
8 | ---
9 |
10 | -Expect status from "/login" with form param "login=admin" and form param "passwd=12345": 302
11 | -Expect cookies:
12 | # Netscape HTTP Cookie File
13 | # https://curl.se/docs/http-cookies.html
14 | # This file was generated by libcurl! Edit at your own risk.
15 |
16 | localhost FALSE / FALSE 0 admin_id ADMIN_SECRET
17 | ---
18 |
19 | -Expect response from "/":
20 |
Hello admin
21 | ---
--------------------------------------------------------------------------------
/functional_tests/route_params/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_route_params_user_defined_types
2 | -Wait: 1 sec
3 |
4 | -Expect status from "/foo": 404
5 |
6 | -Expect response from "/":
7 | Guest book
No messages
8 | ---
9 |
10 | -Expect status from "/" with form param "msg=Hello world!": 302
11 |
12 | -Expect response from "/":
13 | Guest book
Hello world!
14 | ---
15 |
16 | -Expect status from "/" with form param "msg=Hello moon!": 302
17 |
18 | -Expect response from "/":
19 | Guest book
Hello world!
Hello moon!
20 | ---
21 |
22 | -Expect status from post request "/delete/0": 302
23 | -Expect response from "/":
24 | Guest book
Hello moon!
25 | ---
26 |
27 |
--------------------------------------------------------------------------------
/functional_tests/route_params_user_defined_types/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_route_params
2 | -Wait: 1 sec
3 |
4 | -Expect status from "/foo": 404
5 |
6 | -Expect response from "/":
7 | Guest book
No messages
8 | ---
9 |
10 | -Expect status from "/" with form param "msg=Hello world!": 302
11 |
12 | -Expect response from "/":
13 | Guest book
Hello world!
14 | ---
15 |
16 | -Expect status from "/" with form param "msg=Hello moon!": 302
17 |
18 | -Expect response from "/":
19 | Guest book
Hello world!
Hello moon!
20 | ---
21 |
22 | -Expect status from post request "/delete/0": 302
23 | -Expect response from "/":
24 | Guest book
Hello moon!
25 | ---
26 |
27 |
--------------------------------------------------------------------------------
/functional_tests/router/test.toast:
--------------------------------------------------------------------------------
1 | -Launch detached: ../../build/examples/example_router
2 | -Wait: 1 sec
3 |
4 | -Expect status from "/foo": 404
5 |
6 | -Expect response from "/":
7 | Guest book
No messages
8 | ---
9 |
10 | -Expect status from "/" with form param "msg=Hello world!": 302
11 |
12 | -Expect response from "/":
13 | Guest book
Hello world!
14 | ---
15 |
16 | -Expect status from "/" with form param "msg=Hello moon!": 302
17 |
18 | -Expect response from "/":
19 | Guest book
Hello world!
Hello moon!
20 | ---
--------------------------------------------------------------------------------
/functional_tests/timer/test.toast:
--------------------------------------------------------------------------------
1 | -Tags: linux
2 | -Launch detached: ../../build/examples/example_timer
3 | -Wait: 1100 msec
4 |
5 | -Expect response from "/":
6 | Hello world
7 | (alive for 1 seconds)
8 | ---
9 |
10 | -Wait: 1 sec
11 |
12 | -Expect response from "/":
13 | Hello world
14 | (alive for 2 seconds)
15 | ---
16 |
17 | -Expect status from "/foo": 404
--------------------------------------------------------------------------------
/include/asyncgi/asiodispatcher.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_ASIODISPATCHER_H
2 | #define ASYNCGI_ASIODISPATCHER_H
3 |
4 | #include "taskcontext.h"
5 | #include "detail/serviceholder.h"
6 | #include
7 | #include
8 |
9 | namespace asyncgi {
10 | namespace detail {
11 | class AsioDispatcherService;
12 | }
13 |
14 | class IO;
15 | class Responder;
16 |
17 | class AsioDispatcher {
18 | public:
19 | explicit AsioDispatcher(IO&);
20 | explicit AsioDispatcher(Responder&);
21 |
22 | void postTask(std::function task);
23 |
24 | private:
25 | detail::ServiceHolder asioDispatcherService_;
26 | };
27 |
28 | } //namespace asyncgi
29 |
30 | #endif //ASYNCGI_ASIODISPATCHER_H
31 |
--------------------------------------------------------------------------------
/include/asyncgi/asyncgi.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_H
2 | #define ASYNCGI_H
3 |
4 | #include "asiodispatcher.h"
5 | #include "client.h"
6 | #include "errors.h"
7 | #include "events.h"
8 | #include "io.h"
9 | #include "router.h"
10 | #include "server.h"
11 | #include "timer.h"
12 |
13 | #endif //ASYNCGI_H
--------------------------------------------------------------------------------
/include/asyncgi/asyncgi_fwd.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_FWD_H
2 | #define ASYNCGI_FWD_H
3 |
4 | namespace asyncgi {
5 | class IO;
6 | class Request;
7 | class Responder;
8 | class Server;
9 | class Client;
10 | class Error;
11 | class AsioDispatcher;
12 | class TaskContext;
13 | class Timer;
14 |
15 | namespace http {
16 | class Response;
17 | };
18 | namespace fastcgi {
19 | struct Request;
20 | struct Response;
21 | } //namespace fastcgi
22 |
23 | } //namespace asyncgi
24 |
25 | #endif //ASYNCGI_FWD_H
--------------------------------------------------------------------------------
/include/asyncgi/client.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_CLIENT_H
2 | #define ASYNCGI_CLIENT_H
3 |
4 | #include "errors.h"
5 | #include "types.h"
6 | #include "detail/serviceholder.h"
7 | #include "http/request.h"
8 | #include "http/response_view.h"
9 | #include
10 | #include
11 | #include
12 | #include
13 | #include
14 |
15 | namespace asyncgi {
16 | class IO;
17 | class Responder;
18 |
19 | namespace detail {
20 | class ClientService;
21 | }
22 |
23 | class Client {
24 | public:
25 | explicit Client(IO&);
26 | explicit Client(Responder&);
27 |
28 | void makeRequest(
29 | const std::filesystem::path& socketPath,
30 | fastcgi::Request request,
31 | std::function)> responseHandler,
32 | std::chrono::milliseconds timeout = std::chrono::seconds{3});
33 | void makeRequest(
34 | const std::filesystem::path& socketPath,
35 | const http::Request& request,
36 | const std::function)>& responseHandler,
37 | std::chrono::milliseconds timeout = std::chrono::seconds{3});
38 |
39 | void makeRequest(
40 | std::string_view ipAddress,
41 | uint16_t port,
42 | fastcgi::Request request,
43 | std::function)> responseHandler,
44 | std::chrono::milliseconds timeout = std::chrono::seconds{3});
45 | void makeRequest(
46 | std::string_view ipAddress,
47 | uint16_t port,
48 | const http::Request& request,
49 | const std::function)>& responseHandler,
50 | std::chrono::milliseconds timeout = std::chrono::seconds{3});
51 |
52 | void disconnect();
53 |
54 | private:
55 | detail::ServiceHolder clientService_;
56 | };
57 |
58 | } //namespace asyncgi
59 |
60 | #endif //ASYNCGI_CLIENT_H
61 |
--------------------------------------------------------------------------------
/include/asyncgi/detail/asio_namespace.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_ASIO_NAMESPACE_H
2 | #define ASYNCGI_ASIO_NAMESPACE_H
3 |
4 | #ifdef ASYNCGI_USE_BOOST_ASIO
5 | #define ASYNCGI_ASIO boost::asio
6 | namespace boost::asio {
7 | }
8 | namespace asyncgi {
9 | namespace asio = boost::asio;
10 | }
11 | #else
12 | #define ASYNCGI_ASIO asio
13 | namespace asio {
14 | }
15 | namespace asyncgi {
16 | namespace asio = ::asio;
17 | }
18 | #endif
19 |
20 | #endif //ASYNCGI_ASIO_NAMESPACE_H
21 |
--------------------------------------------------------------------------------
/include/asyncgi/detail/eventhandlerproxy.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_EVENTHANDLERPROXY_H
2 | #define ASYNCGI_EVENTHANDLERPROXY_H
3 | #include "utils.h"
4 | #include "external/sfun/utility.h"
5 | #include
6 | #include
7 | #include
8 | #include
9 |
10 | namespace asyncgi::detail {
11 |
12 | class EventHandlerProxy {
13 | public:
14 | EventHandlerProxy();
15 | template<
16 | typename TEventHandler,
17 | std::enable_if_t, EventHandlerProxy>>* = nullptr>
18 | EventHandlerProxy(TEventHandler&& eventHandler)
19 | {
20 | if constexpr (std::is_invocable_v)
21 | errorHandler_ = refWrapperOrRValue(std::forward(eventHandler));
22 | else
23 | static_assert(sfun::dependent_false, "TEventHandler has an incompatible signature");
24 | }
25 |
26 | void operator()(ErrorEvent, std::string_view);
27 |
28 | private:
29 | std::function errorHandler_ = [](ErrorEvent, std::string_view) {};
30 | };
31 |
32 | } //namespace asyncgi::detail
33 |
34 | #endif //ASYNCGI_EVENTHANDLERPROXY_H
35 |
--------------------------------------------------------------------------------
/include/asyncgi/detail/lazyinitialized.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include
3 | #include
4 |
5 | namespace asyncgi::detail {
6 |
7 | template
8 | class LazyInitialized {
9 | public:
10 | explicit LazyInitialized(std::function initializer)
11 | : initializer_{std::move(initializer)}
12 | {
13 | }
14 | operator const T&() const
15 | {
16 | return get();
17 | }
18 | const T& get() const
19 | {
20 | if (!value)
21 | value = initializer_();
22 | return *value;
23 | }
24 |
25 | operator T&()
26 | {
27 | return get();
28 | }
29 | T& get()
30 | {
31 | if (!value)
32 | value = initializer_();
33 | return *value;
34 | }
35 |
36 | private:
37 | mutable std::optional value;
38 | std::function initializer_;
39 | };
40 |
41 | } // namespace asyncgi::detail
--------------------------------------------------------------------------------
/include/asyncgi/detail/routeresponsecontextaccessor.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_ROUTERESPONSECONTEXTACCESSOR_H
2 | #define ASYNCGI_ROUTERESPONSECONTEXTACCESSOR_H
3 |
4 | #include
5 |
6 | namespace asyncgi {
7 | class Responder;
8 |
9 | namespace whaleroute {
10 | class RequestProcessorQueue;
11 | }
12 |
13 | namespace detail {
14 |
15 | struct RouterResponseContextAccessor {
16 | static void setRequestProcessorQueue(Responder&, const std::shared_ptr&);
17 | };
18 |
19 | } //namespace detail
20 |
21 | } //namespace asyncgi
22 |
23 | #endif //ASYNCGI_ROUTERESPONSECONTEXTACCESSOR_H
24 |
--------------------------------------------------------------------------------
/include/asyncgi/detail/serviceholder.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_SERVICE_HOLDER_H
2 | #define ASYNCGI_SERVICE_HOLDER_H
3 |
4 | #include
5 | #include
6 |
7 | namespace asyncgi::detail {
8 |
9 | template
10 | class ServiceHolder {
11 | public:
12 | explicit ServiceHolder(std::unique_ptr);
13 | explicit ServiceHolder(sfun::optional_ref);
14 | ~ServiceHolder();
15 | ServiceHolder(const ServiceHolder&) = delete;
16 | ServiceHolder& operator=(const ServiceHolder&) = delete;
17 | ServiceHolder(ServiceHolder&&) noexcept = default;
18 | ServiceHolder& operator=(ServiceHolder&&) noexcept = default;
19 |
20 | bool has_value() const;
21 | T& get();
22 |
23 | private:
24 | std::unique_ptr service_;
25 | sfun::optional_ref serviceOptionalRef_;
26 | };
27 |
28 | } //namespace asyncgi::detail
29 |
30 | #endif //ASYNCGI_SERVICE_HOLDER_H
31 |
--------------------------------------------------------------------------------
/include/asyncgi/detail/utils.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_UTILS_H
2 | #define ASYNCGI_UTILS_H
3 |
4 | #include
5 |
6 | namespace asyncgi::detail {
7 |
8 | template
9 | auto makeCopyableLambda(TFunc&& f)
10 | {
11 | auto funcPtr = std::make_shared>(std::forward(f));
12 | return [funcPtr](auto&&... args) -> decltype(auto)
13 | {
14 | return (*funcPtr)(decltype(args)(args)...);
15 | };
16 | }
17 |
18 | template
19 | decltype(auto) refWrapperOrRValue(T&& obj)
20 | {
21 | if constexpr (std::is_lvalue_reference_v)
22 | return std::ref(std::forward(obj));
23 | else
24 | return std::forward(obj);
25 | }
26 |
27 | } //namespace asyncgi::detail
28 |
29 | #endif //ASYNCGI_UTILS_H
30 |
--------------------------------------------------------------------------------
/include/asyncgi/errors.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_ERRORS_H
2 | #define ASYNCGI_ERRORS_H
3 | #include
4 |
5 | namespace asyncgi {
6 |
7 | class Error : public std::runtime_error {
8 | using std::runtime_error::runtime_error;
9 | };
10 |
11 | } // namespace asyncgi
12 |
13 | #endif //ASYNCGI_ERRORS_H
--------------------------------------------------------------------------------
/include/asyncgi/events.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_EVENTS_H
2 | #define ASYNCGI_EVENTS_H
3 |
4 | namespace asyncgi {
5 |
6 | enum ErrorEvent {
7 | ConnectionError,
8 | SocketReadError,
9 | SocketWriteError,
10 | SocketCloseError,
11 | RequestProcessingError,
12 | RouteParametersError
13 | };
14 |
15 | } //namespace asyncgi
16 |
17 | #endif //ASYNCGI_EVENTS_H
18 |
--------------------------------------------------------------------------------
/include/asyncgi/io.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_IO_H
2 | #define ASYNCGI_IO_H
3 |
4 | #include "errors.h"
5 | #include "detail/eventhandlerproxy.h"
6 | #include "detail/external/sfun/interface.h"
7 | #include
8 |
9 | namespace asyncgi {
10 | class Server;
11 | class Client;
12 | class Timer;
13 | class AsioDispatcher;
14 | class RouterIOAccess;
15 |
16 | namespace detail {
17 | class IOService;
18 | using IOAccessPermission = sfun::access_permission;
19 | } //namespace detail
20 |
21 | class IO {
22 |
23 | public:
24 | template
25 | explicit IO(int threadsNumber, TEventHandler&& eventHandler)
26 | : IO(threadsNumber)
27 | {
28 | eventHandler_ = std::forward(eventHandler);
29 | }
30 |
31 | template
32 | explicit IO(TEventHandler&& eventHandler)
33 | : IO(1)
34 | {
35 | eventHandler_ = std::forward(eventHandler);
36 | }
37 | explicit IO(int threadsNumber = 1);
38 |
39 | ~IO();
40 | IO(const IO&) = delete;
41 | IO& operator=(const IO&) = delete;
42 | IO(IO&&) = delete;
43 | IO& operator=(IO&&) = delete;
44 |
45 | void run();
46 | void stop();
47 |
48 | /// detail
49 | detail::EventHandlerProxy& eventHandler(detail::IOAccessPermission);
50 | detail::IOService& ioService(detail::IOAccessPermission);
51 |
52 | private:
53 | std::unique_ptr ioService_;
54 | detail::EventHandlerProxy eventHandler_;
55 | };
56 |
57 | } //namespace asyncgi
58 |
59 | #endif //ASYNCGI_IO_H
60 |
--------------------------------------------------------------------------------
/include/asyncgi/request.h:
--------------------------------------------------------------------------------
1 | #ifndef ASYNCGI_REQUEST_H
2 | #define ASYNCGI_REQUEST_H
3 |
4 | #include "detail/external/sfun/member.h"
5 | #include "detail/lazyinitialized.h"
6 | #include "http/cookie_view.h"
7 | #include "http/query_view.h"
8 | #include "http/request_view.h"
9 | #include "http/types.h"
10 | #include
11 | #include 
3 |