Send multiple responses to the browser from boost asio - c++

Question

I am developing a HTTPS server that receives a request and must answer with 3 responses. The first two are something line ACKs, and the last one contains the requested information.
I am using my web browser (chrome) as client. What I want is the following:
The browser (client) sends a request to the server.
The server sends the first ACK (an html page) and the browser displays it.
After two seconds, the server send another ACK (a different html page) and the browser displays it.
After another two seconds, the server sends the requested information (a different html page) and the browser displays it.
The problem is that the browser only receives the first ACK, it seems that it is closing the socket after reading it, even setting the Connection to keep-alive in the HTTPS header.
Is there any way to be waiting for several HTTPS responses with the web browser?
Source
This contains the async methods executed by the server when a petition is made:
void handle_handshake(const boost::system::error_code& error)
{
if (!error)
{
boost::asio::async_read_until(socket_, request_, "\r\n\r\n",
boost::bind(&session::handle_read, this,
boost::asio::placeholders::error));
}
else
{
std::cout << "ERROR, deleting. " << __FILE__ << ":" << __LINE__ << std::endl;
delete this;
}
}
void handle_read(const boost::system::error_code& err)
{
if (!err)
{
std::string s = "some_response";
// First write. This write is received by the browser without problems.
boost::asio::async_write(socket_,
boost::asio::buffer(response),
boost::bind(&session::handle_write, this,
boost::asio::placeholders::error));
}
else
{
std::cout << "Error: " << err << "\n";
}
}
void handle_write(const boost::system::error_code& error)
{
if (!error)
{
if(n++ <= 2)
{
// Second and third writes.
// These ones are not read by the browser.
if(n == 1)
{
std::string s = "some_response2";
boost::asio::async_write(socket_,
boost::asio::buffer(response),
boost::bind(&session::handle_write, this,
boost::asio::placeholders::error));
}
else if (n==2)
{
std::string s = "some_response3";
boost::asio::async_write(socket_,
boost::asio::buffer(response),
boost::bind(&session::handle_write, this,
boost::asio::placeholders::error));
}
sleep(1);
}
}
else
{
std::cout << "ERROR, deleting: " << __FILE__ << ":" << __LINE__ << std::endl;
delete this;
}
}

Answer 1

Okay you want to overcome the slow start i.e taking a new connection and doing 3-way handshake for new connections— a full roundtrip of latency.
Although I could not get a proper code snippet of how you're doing this. A wild guess is you must have forgotten to set the timeout (SO_RCVTIMEO and SO_SNDTIMEO) for keep-alive connection or using a wrong HTTP version.
Note: Keep-alive connections are enabled by default in HTTP/1.1 while not in HTTP/1.0. HTTP/1.0 was designed to close the connection after every request between client and server. We can actually check this difference using telnet.
From the performance perspective, I wrote two (python) scripts — one uses the same connection for 50 consecutive requests and one initiates a new connection for every request.
Average time with keep-alive/persistent connections: 7.00 seconds
Average time with new connections: 22.38 seconds
It is a difference of almost 3 orders which makes sense as we know with keep-alive/persistent connections, the three-way handshake (a full roundtrip of latency) is avoided. The slow-start wouldn’t have much impact here because the request and response are quite small so the amount of bandwidth required is pretty low.
PS: Go through this in case it helps
boost::asio::ip::tcp::socket socket(io_service);
...
boost::asio::socket_base::keep_alive option;
socket.get_option(option);
Client need to keep the port open as servers are configured(pre-assumed) to listen to a particular application at a particular port
I got the above snippet from here