https://github.com/Stiffstream/restinio

Cross-platform, efficient, customizable, and robust asynchronous HTTP(S)/WebSocket server C++ library with the right balance between performance and ease of use
https://github.com/Stiffstream/restinio

asio cplusplus cpp http http-server https library linux rest tls-support websockets windows

Last synced: 3 months ago
JSON representation

Cross-platform, efficient, customizable, and robust asynchronous HTTP(S)/WebSocket server C++ library with the right balance between performance and ease of use

• Host: GitHub
• URL: https://github.com/Stiffstream/restinio
• Owner: Stiffstream
• License: other
• Created: 2017-12-25T20:34:27.000Z (almost 7 years ago)
• Default Branch: master
• Last Pushed: 2024-07-22T05:56:49.000Z (4 months ago)
• Last Synced: 2024-07-22T07:05:39.166Z (4 months ago)
• Topics: asio, cplusplus, cpp, http, http-server, https, library, linux, rest, tls-support, websockets, windows
• Language: C++
• Homepage:
• Size: 8.65 MB
• Stars: 1,134
• Watchers: 40
• Forks: 92
• Open Issues: 38
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# What Is RESTinio?

RESTinio is a C++17 library that gives you an embedded

HTTP/Websocket server. It is based on standalone version of ASIO

and targeted primarily for asynchronous processing of HTTP-requests.

Boost::ASIO is also supported.

RESTinio itself is a header-only library, but it depends on [nodejs/llhttp](https://github.com/nodejs/llhttp)

that is not header-only.

Currently *RESTinio* is in rather stable state and we think that since v.0.4.0

it is ready for production use.

# A Very Basic Example Of RESTinio

Consider the task of writing a C++ application that must support some REST API,

RESTinio represents our solution for that task.

Lets see how it feels like in the simplest case:

```C++

#include 

int main()

{

    restinio::run(

        restinio::on_this_thread()

        .port(8080)

        .address("localhost")

        .request_handler([](auto req) {

            return req->create_response().set_body("Hello, World!").done();

        }));

    return 0;

}

```

Server runs on the main thread, and respond to all requests with hello-world

message. Of course you've got an access to the structure of a given HTTP request,

so you can apply a complex logic for handling requests.

# Features

* Async request handling. Cannot get the response data immediately? That's ok,

  store request handle somewhere and/or pass it to another execution context

  and get back to it when the data is ready.

* HTTP pipelining. Works well with async request handling.

  It might increase your server throughput dramatically.

* Timeout control. RESTinio can take care of bad connection that are like: send

  "GET /" and then just stuck.

* Response builders. Need chunked-encoded body - then RESTinio has a special

  response builder for you (obviously it is not the only builder).

* ExpressJS-like request routing (see an example below).

* An experimental typesafe request router that allows avoiding problems of ExpressJS-like router with help of static checks from C++ compiler.

* A possibility to chain several request-handlers (somewhat similar to ExpressJS's middleware).

* Working with query string parameters.

* Several ready-to-use helpers for working with HTTP headers (for example, the support for HTTP headers related to file uploading).

* Supports sending files and its parts (with sendfile on linux/unix and TransmitFile on windows).

* Supports compression (deflate, gzip).

* Supports TLS (HTTPS).

* Basic websocket support. Simply restinio::websocket::basic::upgrade() the

  request handle and start websocket session on a corresponding connection.

* Can run on external asio::io_context. RESTinio is separated from execution

  context.

* Some tune options. One can set acceptor and socket options. When running

  RESTinio on a pool of threads connections can be accepted in parallel.

# Enhanced Example With Express Router

```C++

#include 

using namespace restinio;

template

std::ostream & operator<<(std::ostream & to, const optional_t & v) {

    if(v) to << *v;

    return to;

}

int main() {

    // Create express router for our service.

    auto router = std::make_unique>();

    router->http_get(

            R"(/data/meter/:meter_id(\d+))",

            [](auto req, auto params) {

                const auto qp = parse_query(req->header().query());

                return req->create_response()

                        .set_body(

                                fmt::format("meter_id={} (year={}/mon={}/day={})",

                                        cast_to(params["meter_id"]),

                                        opt_value(qp, "year"),

                                        opt_value(qp, "mon"),

                                        opt_value(qp, "day")))

                        .done();

            });

    router->non_matched_request_handler(

            [](auto req){

                return req->create_response(restinio::status_not_found()).connection_close().done();

            });

    // Launching a server with custom traits.

    struct my_server_traits : public default_single_thread_traits_t {

        using request_handler_t = restinio::router::express_router_t<>;

    };

    restinio::run(

            restinio::on_this_thread()

                    .address("localhost")

                    .request_handler(std::move(router)));

    return 0;

}

```

# License

RESTinio is distributed under BSD-3-CLAUSE license.

# How To Use It?

The full documentation for RESTinio can be found [here](https://stiffstream.com/en/docs/restinio/0.7/).

# More

* Issues and bugs:

[Issue Tracker on GitHub](https://github.com/stiffstream/restinio/issues).

* Discussion section [on GitHub](https://github.com/Stiffstream/restinio/discussions).

* Discussion group: [restinio](https://groups.google.com/forum/#!forum/restinio).