Shrimp: A Rather Practical Example Of Application Development With RESTinio and SObjectizer

A few words about us
●
●
2

What is Shrimp? From 30000 feets
4

Why Shrimp was created?
●
●
●
5

What is Shrimp? Actually
●
●
8

Shrimp in a simple example
10
$ curl -o test.webp
"https://shrimp-demo.stiffstream.com/DSCF6555.jpg?op=resize&width=300&target-format=webp"
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 41162 100 41162 0 0 41162 0 0:00:01 --:--:-- 0:00:01 151k
$ ls -l *.webp
-rw-rw-r-- 1 eao197 eao197 41162 сен 4 08:28 test.webp

Shrimp in a simple example
11
$ curl -o test.webp
"https://shrimp-demo.stiffstream.com/DSCF6555.jpg?op=resize&width=300&target-format=webp"
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 41162 100 41162 0 0 41162 0 0:00:01 --:--:-- 0:00:01 151k
$ ls -l *.webp
-rw-rw-r-- 1 eao197 eao197 41162 сен 4 08:28 test.webp

More formal description
/<file-name>[?params]
●
●
●
12

Examples
/DSCF6555.jpg
/DSCF6555.jpg?target-format=heic
/DSCF6555.jpg?op=resize&max=1024
/DSCF6555.jpg?op=resize&max=1024&target-format=heic
13

Technical details start here...
18

Shrimp's internals in a few words
●
●
●
19

A picture is worth a thousand words
20

What is used inside Shrimp?
21

RESTinio in Shrimp
●
●
●
●
23

External Asio context
●
●
24

io_context
io_context
run()
25

// ASIO io_context must outlive sobjectizer.
asio::io_context asio_io_ctx;
// Launch SObjectizer and wait while balancer will be started.
...
so_5::wrapped_env_t sobj{
[&]( so_5::environment_t & env ) {...},
[&]( so_5::environment_params_t & params ) {...} };
// Now we can launch HTTP-server.
restinio::run(
asio_io_ctx,
shrimp::make_http_server_settings(...) );
26

...
restinio::run(
asio_io_ctx,
27
Asio's io_context object is created.

...
restinio::run(
asio_io_ctx,
28
SObjectizer is started here.
SObjectizer will be stopped and destroyed before
destruction of io_context.

...
restinio::run(
asio_io_ctx,
29
RESTinio is started here.
restinio::run() returns only after
shutdown of HTTP-server.

Wrapper around spdlog's logger
class http_server_logger_t
{
public:
http_server_logger_t( std::shared_ptr<spdlog::logger> logger ) : m_logger{std::move(logger)} {}
template<typename Builder> void trace( Builder && msg_builder ) {
log_if_enabled( spdlog::level::trace, std::forward<Builder>(msg_builder) );
}
template<typename Builder> void info( Builder && msg_builder ) {
log_if_enabled( spdlog::level::info, std::forward<Builder>(msg_builder) );
}
...
private:
template<typename Builder> void log_if_enabled(
spdlog::level::level_enum lv, Builder && msg_builder ) {
if( m_logger->should_log(lv) ) { m_logger->log( lv, msg_builder() ); }
}
std::shared_ptr<spdlog::logger> m_logger;
};
31

Tie our wrapper type with RESTinio's traits
struct http_server_traits_t
: public restinio::default_traits_t
{
using logger_t = http_server_logger_t;
using request_handler_t = http_req_router_t;
};
32

Tie our wrapper type with RESTinio's traits
{
};
33
Now RESTinio server with this traits will use
instance of http_server_logger_t for logging.

Instantiation of our wrapper
[[nodiscard]] inline auto
make_http_server_settings(
unsigned int thread_pool_size,
const app_params_t & params,
std::shared_ptr<spdlog::logger> logger,
so_5::mbox_t req_handler_mbox )
{
...
return restinio::on_thread_pool< http_server_traits_t >( thread_pool_size )
.port( http_srv_params.m_port )
.protocol( ip_protocol(http_srv_params.m_ip_version) )
.address( http_srv_params.m_address )
.handle_request_timeout( std::chrono::seconds(60) )
.write_http_response_timelimit( std::chrono::seconds(60) )
.logger( std::move(logger) )
.request_handler( make_router( params, req_handler_mbox ) );
}
34

{
...
}
35

{
...
}
36
Object of type http_server_traits_t::logger_t
(aka http_server_logger_t) will be created here.
Spdlog's logger will be passed to the
constructor of that object.

Log example (with --restinio-tracing -l trace)
37

ExpressJS-like routing
using http_req_router_t =
restinio::router::express_router_t<
restinio::router::pcre_regex_engine_t<
restinio::router::pcre_traits_t<
// Max capture groups for regex.
5 > > >;
39

using http_req_router_t =
restinio::router::express_router_t<
restinio::router::pcre_regex_engine_t<
restinio::router::pcre_traits_t<
// Max capture groups for regex.
5 > > >;
40
Express router can use different engines.
There are engines based on std::regex, Boost.Regex
and PCRE/PCRE2.
A PCRE-based engine is used here.

{
};
41

void add_transform_op_handler(
const app_params_t & app_params,
http_req_router_t & router,
{
router.http_get(
R"(/:path(.*).:ext(.{3,4}))",
restinio::path2regex::options_t{}.strict( true ),
[req_handler_mbox, &app_params]( auto req, auto params ) {...} );
}
42

void add_transform_op_handler(
const app_params_t & app_params,
http_req_router_t & router,
{
router.http_get(
R"(/:path(.*).:ext(.{3,4}))",
restinio::path2regex::options_t{}.strict( true ),
[req_handler_mbox, &app_params]( auto req, auto params ) {...} );
}
43
A route with two arguments ('path' and 'ext') is defined here.

sendfile for serving original files
sendfile() TransmitFile()
44

[[nodiscard]] restinio::request_handling_status_t
serve_as_regular_file(const std::string & root_dir, restinio::request_handle_t req, image_format_t image_format)
{
const auto full_path = make_full_path( root_dir, req->header().path() );
try {
auto sf = restinio::sendfile( full_path );
const auto last_modified = sf.meta().last_modified_at();
auto resp = req->create_response();
return set_common_header_fields_for_image_resp( last_modified, resp )
.append_header( restinio::http_field::content_type, image_content_type_from_img_format(image_format) )
.append_header( restinio::http_header_field_t{
http_header::shrimp_image_src_hf(),
image_src_to_str( http_header::image_src_t::sendfile ) } )
.set_body( std::move(sf) )
.done();
}
catch(...) { }
return do_404_response( std::move( req ) );
}
45

{
try {
.done();
}
catch(...) { }
}
46
sendfile operation is defined here.

{
try {
.done();
}
catch(...) { }
}
47
sendfile operation is used here for sending file's content as
response's body.

transformer agent
class a_transformer_t final : public so_5::agent_t
{
public:
struct resize_request_t final : public so_5::message_t {...};
a_transformer_t(context_t ctx, std::shared_ptr<spdlog::logger> logger, storage_params_t cfg);
void so_define_agent() override {
so_subscribe_self().event( &a_transformer_t::on_resize_request );
}
private:
...
on_resize_request(mutable_mhood_t<resize_request_t> cmd);
...
};
52

transformer agent
{
public:
}
private:
...
...
};
53
Message to be handled.

transformer agent
{
public:
}
private:
...
...
};
54
Subscription to the message.
When message resize_request_t arrives the
on_resize_request() method will be called.
Type of message to be subscribed is deduced from
handler's prototype.

transform_manager agent (1)
class a_transform_manager_t final : public so_5::agent_t
{
public:
struct resize_result_t final : public so_5::message_t {...};
struct delete_cache_request_t final : public so_5::message_t {...};
a_transform_manager_t(context_t ctx, std::shared_ptr<spdlog::logger> logger);
void so_define_agent() override;
void so_evt_start() override;
...
56

class a_transform_manager_t final : public so_5::agent_t
{
public:
struct resize_result_t final : public so_5::message_t {...};
struct delete_cache_request_t final : public so_5::message_t {...};
a_transform_manager_t(context_t ctx, std::shared_ptr<spdlog::logger> logger);
void so_define_agent() override;
void so_evt_start() override;
...
57
Those are "public" messages. They are sent to transform_manager by external
entities:
● resize_request_t and delete_cache_request_t are sent by HTTP-server;
● resize_result_t is sent by transformer agent.

private :
struct negative_delete_cache_response_t : public so_5::message_t {...};
struct clear_cache_t final : public so_5::signal_t {};
struct check_pending_requests_t final : public so_5::signal_t {};
...
void on_resize_request(mutable_mhood_t<resize_request_t> cmd);
void on_resize_result(mutable_mhood_t<resize_result_t> cmd);
void on_delete_cache_request(mutable_mhood_t<delete_cache_request_t> cmd);
void on_negative_delete_cache_response(
mutable_mhood_t<negative_delete_cache_response_t> cmd);
void on_clear_cache(mhood_t<clear_cache_t>);
void on_check_pending_requests(mhood_t<check_pending_requests_t>);
...
};
58

private :
struct negative_delete_cache_response_t : public so_5::message_t {...};
struct clear_cache_t final : public so_5::signal_t {};
struct check_pending_requests_t final : public so_5::signal_t {};
...
void on_resize_request(mutable_mhood_t<resize_request_t> cmd);
void on_resize_result(mutable_mhood_t<resize_result_t> cmd);
void on_delete_cache_request(mutable_mhood_t<delete_cache_request_t> cmd);
void on_negative_delete_cache_response(
mutable_mhood_t<negative_delete_cache_response_t> cmd);
void on_clear_cache(mhood_t<clear_cache_t>);
void on_check_pending_requests(mhood_t<check_pending_requests_t>);
...
};
59
Those are "private" message and signals. transform_manager sends them to itself.

void a_transform_manager_t::so_define_agent()
{
so_subscribe_self()
.event( &a_transform_manager_t::on_resize_request )
.event( &a_transform_manager_t::on_resize_result )
.event( &a_transform_manager_t::on_delete_cache_request )
.event( &a_transform_manager_t::on_negative_delete_cache_response )
.event( &a_transform_manager_t::on_clear_cache )
.event( &a_transform_manager_t::on_check_pending_requests );
}
60

Basic working scheme
a_transform_manager_t::resize_request_t
61

a_transform_manager_t::resize_request_t
62
void handle_resize_op_request(
const so_5::mbox_t & req_handler_mbox,
image_format_t image_format,
const restinio::query_string_params_t & qp,
restinio::request_handle_t req )
{
try_to_handle_request( [&]{
auto op_params = transform::resize_params_t::make(
restinio::opt_value< std::uint32_t >( qp, "width" ),
restinio::opt_value< std::uint32_t >( qp, "height" ),
restinio::opt_value< std::uint32_t >( qp, "max" ) );
transform::resize_params_constraints_t{}.check( op_params );
std::string image_path{ req->header().path() };
so_5::send< so_5::mutable_msg<a_transform_manager_t::resize_request_t> >(
req_handler_mbox,
std::move(req), std::move(image_path), image_format, op_params );
},
req );
}

a_transformer_t::resize_request_t
63

a_transformer_t::resize_request_t
64
void a_transform_manager_t::try_initiate_pending_requests_processing()
{
while( !m_free_workers.empty() && !m_pending_requests.empty() ) {
auto atoken = m_pending_requests.oldest().value();
const auto key = atoken.key();
m_pending_requests.extract_values_for_key( std::move(atoken),
[&]( auto && value ) {
m_inprogress_requests.insert( transform::resize_request_key_t{key}, std::move(value) );
} );
auto worker = std::move(m_free_workers.top());
m_free_workers.pop();
m_logger->trace("initiate processing of a request; request_key={}, worker_mbox={}",
key, worker->id());
so_5::send< so_5::mutable_msg<a_transformer_t::resize_request_t> >(worker, key, so_direct_mbox());
}
}

a_transform_manager_t::resize_result_t
65

a_transform_manager_t::resize_result_t
66
void a_transformer_t::on_resize_request(
mutable_mhood_t<resize_request_t> cmd)
{
auto result = handle_resize_request( cmd->m_key );
so_5::send< so_5::mutable_msg<a_transform_manager_t::resize_result_t> >(
cmd->m_reply_to,
so_direct_mbox(),
std::move(cmd->m_key),
std::move(result) );
}

68
void a_transform_manager_t::on_resize_result(
mutable_mhood_t<resize_result_t> cmd )
{
m_logger->trace( "resize_result received; request_key={}, worker_mbox={}",
cmd->m_key,
cmd->m_worker->id() );
m_free_workers.push( std::move(cmd->m_worker) );
try_initiate_pending_requests_processing();
auto key = std::move(cmd->m_key);
auto requests = extract_inprogress_requests(
std::move(m_inprogress_requests.find_first_for_key( key ).value()) );
std::visit( variant_visitor{
[&]( successful_resize_t & result ) {
on_successful_resize( std::move(key), result, std::move(requests) );
},
[&]( failed_resize_t & result ) {
on_failed_resize( std::move(key), result, std::move(requests) );
} },
cmd->m_result );
}

69
void a_transform_manager_t::on_resize_result(
mutable_mhood_t<resize_result_t> cmd )
{
m_logger->trace( "resize_result received; request_key={}, worker_mbox={}",
cmd->m_key,
cmd->m_worker->id() );
m_free_workers.push( std::move(cmd->m_worker) );
try_initiate_pending_requests_processing();
auto key = std::move(cmd->m_key);
auto requests = extract_inprogress_requests(
std::move(m_inprogress_requests.find_first_for_key( key ).value()) );
std::visit( variant_visitor{
[&]( successful_resize_t & result ) {
on_successful_resize( std::move(key), result, std::move(requests) );
},
[&]( failed_resize_t & result ) {
on_failed_resize( std::move(key), result, std::move(requests) );
} },
cmd->m_result );
}
void a_transform_manager_t::on_failed_resize(
transform::resize_request_key_t key,
failed_resize_t & result,
original_request_container_t requests )
{
m_logger->warn( "failed resize; request_key={}, reason={}", key, result.m_reason );
for( auto & rq : requests )
{
m_logger->trace( "sending negative response back; request_key={}, connection_id={}",
key, rq->m_http_req->connection_id() );
do_404_response( std::move(rq->m_http_req) );
}
}

Providing work threads to agents
70

Providing work threads to agents (1)
[[nodiscard]] so_5::mbox_t
create_agents(
spdlog::sink_ptr logger_sink,
const shrimp::app_params_t & app_params,
so_5::environment_t & env,
unsigned int worker_threads_count )
{
using namespace shrimp;
using namespace so_5::disp::one_thread; // For create_private_disp.
so_5::mbox_t manager_mbox;
env.introduce_coop([&]( so_5::coop_t & coop ) {
auto manager = coop.make_agent_with_binder< a_transform_manager_t >(
create_private_disp( env, "manager" )->binder(),
make_logger( "manager", logger_sink ) );
manager_mbox = manager->so_direct_mbox();
71

[[nodiscard]] so_5::mbox_t
create_agents(
spdlog::sink_ptr logger_sink,
const shrimp::app_params_t & app_params,
so_5::environment_t & env,
unsigned int worker_threads_count )
{
using namespace shrimp;
using namespace so_5::disp::one_thread; // For create_private_disp.
so_5::mbox_t manager_mbox;
env.introduce_coop([&]( so_5::coop_t & coop ) {
auto manager = coop.make_agent_with_binder< a_transform_manager_t >(
create_private_disp( env, "manager" )->binder(),
make_logger( "manager", logger_sink ) );
manager_mbox = manager->so_direct_mbox();
72
transform_manager agent is created and is bound to separate
one_thread dispatcher. It means that transform_manager will
have its own work thread.

// Every worker will work on its own private dispatcher.
for( unsigned int worker{}; worker < worker_threads_count; ++worker )
{
const auto worker_name = fmt::format( "worker_{}", worker );
auto transformer = coop.make_agent_with_binder< a_transformer_t >(
create_private_disp( env, worker_name )->binder(),
make_logger( worker_name, logger_sink ),
app_params.m_storage );
manager->add_worker( transformer->so_direct_mbox() );
}
} );
return manager_mbox;
}
73

// Every worker will work on its own private dispatcher.
for( unsigned int worker{}; worker < worker_threads_count; ++worker )
{
const auto worker_name = fmt::format( "worker_{}", worker );
auto transformer = coop.make_agent_with_binder< a_transformer_t >(
create_private_disp( env, worker_name )->binder(),
make_logger( worker_name, logger_sink ),
app_params.m_storage );
manager->add_worker( transformer->so_direct_mbox() );
}
} );
return manager_mbox;
}
74
The same is for every transformer agent.

The results of the experiment
76

It's not a 10-lines HelloWorld
77

#include <restinio/all.hpp>
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;
}
78

int main()
{
restinio::run(
.port(8080)
}));
return 0;
}
79

int main()
{
restinio::run(
.port(8080)
}));
return 0;
}
80

New ideas for implementation
81

We are open for new ideas...
82

Shrimp: A Rather Practical Example Of Application Development With RESTinio and SObjectizer

More Related Content

What's hot (20)

Similar to Shrimp: A Rather Practical Example Of Application Development With RESTinio and SObjectizer (20)

More from Yauheni Akhotnikau (20)

Recently uploaded (20)

Shrimp: A Rather Practical Example Of Application Development With RESTinio and SObjectizer