How to get PUT/POST/PATCH payload data? Details on the flow of res->onData(lambda) please.

[ddevienne]

I'd got GET, HEAD, and OPTIONS (CORS anyone...) kinda covered (I'm far from an expert...).

uWebSockets is single threaded by design. And so far, everything looked like straight-line code.
But I tried registering an onData() handler thus (no pitch forks please):

        HighResTimer timer;
        std::string body;
        body.reserve(rpc.content_length_);
        std::promise<bool> got_payload;
        rpc.res_->onData([&body, &got_payload](auto payload, bool fin) {
            body.append(payload);
            if (fin) {
                got_payload.set_value(true);
            }
        });
        auto fut = got_payload.get_future();
        auto status = fut.wait_for(std::chrono::seconds(5));
        if (status == std::future_status::timeout) {
            rpc.setStatus(408, "408 Request Timeout"sv);
            rpc.end();
            return;
        }
        fmt::print(
            rpc.ctx_.cli_ctx_->out(),
            "Got Payload! Expected {}, got {}. After {}\n",
            rpc.content_length_, body.size(), timer.elapsed()
        );

Naively thinking onData() would magically get data in the background and block until it got it all.
Well, it was my first try at least. But what happens is I return with the 408 Request Timeout and unwind
the stack, and later my lambda is called, except of course the stack frame is gone :)

So it looks like this is some kind of continuation, after registering the onData() handler,
I need to return from the first handler, so the framework gets back the handle, and can resume
the handling of the request later (probably taking care of the onAborted() case too),
to complete the processing of the request. And I can do streaming processing if I can, or buffer
the payload and wait for fin to proceed.

But that breaks down for me, because my rpc helper (which wraps the res and req) is on the stack,
in the frame called by the handler. So would be gone by the time the continuation is called.

And I also read (in the doc or the code, I don't recall), that the res and req are also stack based,
so can I still safely reference them from the continuation? Are they still guaranteed to be alive?

Is so, I've need to std::move() my stack-allocated rpc helper into the heap, or the lambda's state.

The last guy asking about onData() in the Discussion forum got shot down by some guy,
and didn't get any answer from the master. I'm hoping I've shown I've done my homework
and I'll get a more lenient treatment?

Just a high-level description of the code flow for a POST, and details on the lifetime of res and req
in that flow, would be really helpful. FWIW. Thanks, --DD

Update: The Crs32.cpp example shows res, a pointer, captured by value and used later.
And also onData() and onAborted() communicating via heap-allocated shared state.
And I guess there's no race, since this is single-threaded. Can I suppose req is similarly alive?

[uNetworkingAB]

Req is stack allocated, Res is not. If you want to respond to a POST without doing any allocations (let's say you get all body in one go), you look at the headers and distill the information you need down to X, then you capture X in the onData lambda.

But you can also just attach a different lambda with different code based on your headers and URL, then you don't need any X to capture (more than you would either way)

[uNetworkingAB]

would magically get data in the background and block until it got it all.

It's a single threaded library, not Apache HTTP Server. You need to take the time to understand what that means before bolting on incompatible threading primitives. Pretty sure I mentioned this in the first message you wrote. You can study Node.js for a quick introduction.