sending data out of mongoose polling context

[tianleizhang]

I am trying to use mongoose library to make a gateway device and the following scenarios require filling up the mg_connection::send buffer out of the mg_poll() context:

1. as a HTTP server, when the HTTP request comes, the device need to gather information from the LAN first and once the information is ready send back the HTTP response. While gathering the information, the mg_poll() cannot be blocked;
2. I need to implement a websocket service, where I can continuously push log messages gathered form other devices in the LAN to the websocket.
   Here is my thought:
3. when such connection is created, I will allocate a secondary mg_iobuf that can be referenced from mg_connection::data.
4. when preparing the HTTP response, or the log messages, I will not put the data into mg_conneciton::send, but into the secondary mg_iobuf instead;
5. in MG_EV_POLL handling, I will check if mg_connection::send and the secondary mg_iobuf. If mg_connection::send is empty but the secondary mg_iobuf is not, I will swap the two IO bufers (exchange their member values), I will to make sure of the atomicity of the swapping.
6. when the connection is closed, I will delete the secondary mg_iobuf.
   Is this a viable solution? or is there anything else I need to consider to make this work?
   Thank you!

[scaprile]

I see three possible paths:

• polling
• "async"
• multithreading

Polling

As long as you don't violate the other end maximum wait time, nobody forces you to send a response immediately. When calling your event handler, Mongoose sets the is_resp flag https://mongoose.ws/documentation/#connection-flags , it will be reset when you call mg_http_reply(), but if you don't call it and just return, nothing will be sent and this connection will be kept open and waiting.
At a poll event, when you know your response is ready, you just call mg_http_reply().
Please read https://mongoose.ws/documentation/#best-practices
If you use mg_printf() or mg_send() instead, don't forget to set Content-Length and c->is_resp yourself

"Async"

If for some reason you don't want to use the poll event, you can store your connection somewhere and call mg_http_reply from some other point in your main loop. This function will fill the TCP buffer but data won't be sent until the manager runs.
Not strictly that, but you get the idea: https://mongoose.ws/documentation/tutorials/http/http-reverse-proxy/ . In this example, one connection receives a request and passes a connection to itself to other connection, that returns the data
There is only one context here, the main context; no interrupts, no multithreading, you just call a TCP send function from outside the manager, that is perfectly legal usage

Multihreading

From the docs

NOTE: Since Mongoose's core is not protected against concurrent accesses, make sure that all mg_* API functions are called from the same thread or RTOS task.

If you absolutely need multi-threading, take the time to go through the user guide (linked above) and tutorials, there is one that shows you how to do multi-threading.

Please see our documentation, and follow the guidelines in our tutorials.

[tianleizhang]

Hi Scaprile, thanks for your reply.

Although I am using Mongoose in multithreading environment (freeRTOS), the multithreading solution is too complicated (creation/deletion of worker thread and temporary data buffer) and also not very efficient (data prepared by the worker task in a temporary buffer have to be moved into the IO buffer). The other options are also not efficient either due to the same reason.

What I am trying to achieve:

1. make asynchronous HTTP response and WebSocket data push thread safe.
2. make the above operation more efficient, and avoid copying data around.

The idea is simple, just to define two IO buffers for mg_connection::send, one original an one backup, and use them alternatively in a ping-pong fashion. This way, the producer thread can safely write to the backup IO buffer without worrying about any conflict with the mg_poll() thread (the consumer), When mg_poll() runs, it only needs to check if IO buffer swapping is needed. After the buffers are swapped, the data inside the buffer will be ready to use, no need to move them! This kind of efficiency is import when I have large amount of log messages to be pushed through the WebSocket connection.

Interestingly I have tried the following:
After the HTTP request is received, in MG_EV_HTTP_MSG handling, instead of replying the request, I started the process of gathering information from the local network. The required information comes from the network in several chunks. The received information chunk is handled in Ethernet ISR context. I cannot simply print it to the mg_connection::send IO buffer before the whole information has been received, since as soon as the mg_poll() detects some data in the IO buffer, it will send it right away. This will cause problem in HTTP response since the response is not complete. Besides of manipulating with c->is_resp flag, I created another flag called c->is_responding. This flag will prevent can_write() function from returning TRUE if its value is 1. With this flag, I am signal the core when the content of the buffer can be sent (my understanding of the c->is_resp flag is to signal the core when the next HTTP request can be processed). This method works very.

With the above experiment, I am confident that the ping-pong IO buffer method should work, just wondering if there is anything important that I may have missed before I give it a try.

[scaprile]

You have been given two simplest solutions before multithreaded.
You are free to do as you please, it is your project