Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Support for gzip compression when using http 1.1; giving gzip precendence

Browse Source
This commit is contained in:
Dennis Luxen 2011-02-13 11:15:56 +00:00
parent d0547f3d69
commit 221080e281
4 changed files with 121 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Server/BasicDatastructures.h
View File

@ -45,7 +45,7 @@ struct Header {
}; };
enum CompressionType { enum CompressionType {
none, noCompression,
gzipRFC1952, gzipRFC1952,
deflateRFC1951 deflateRFC1951
} Compression; } Compression;

71
Server/Connection.h
View File

@ -56,38 +56,47 @@ public:
private: private:
void handleRead(const boost::system::error_code& e, std::size_t bytes_transferred) { void handleRead(const boost::system::error_code& e, std::size_t bytes_transferred) {
if (!e) { if (!e) {
CompressionType compressionType(none); CompressionType compressionType(noCompression);
boost::tribool result; boost::tribool result;
boost::tie(result, boost::tuples::ignore) = requestParser.Parse( request, incomingDataBuffer.data(), incomingDataBuffer.data() + bytes_transferred, &compressionType); boost::tie(result, boost::tuples::ignore) = requestParser.Parse( request, incomingDataBuffer.data(), incomingDataBuffer.data() + bytes_transferred, &compressionType);
if (result) { if (result) {
// std::cout << "----" << std::endl; // std::cout << "----" << std::endl;
// if(compressionType == gzipRFC1952) // if(compressionType == gzipRFC1952)
// std::cout << "[debug] supports gzip" << std::endl; // std::cout << "[debug] using gzip" << std::endl;
// if(compressionType == deflateRFC1951) // if(compressionType == deflateRFC1951)
// std::cout << "[debug] Supports deflate" << std::endl; // std::cout << "[debug] using deflate" << std::endl;
// if(compressionType == noCompression)
// std::cout << "[debug] no compression" << std::endl;
requestHandler.handle_request(request, reply); requestHandler.handle_request(request, reply);
if(compressionType == deflateRFC1951) {
Header compressionHeader; Header compressionHeader;
std::vector<unsigned char> compressed;
std::vector<boost::asio::const_buffer> outputBuffer;
switch(compressionType) {
case deflateRFC1951:
compressionHeader.name = "Content-Encoding"; compressionHeader.name = "Content-Encoding";
compressionHeader.value = "deflate"; compressionHeader.value = "deflate";
reply.headers.insert(reply.headers.begin(), compressionHeader); //push_back(compressionHeader); reply.headers.insert(reply.headers.begin(), compressionHeader); //push_back(compressionHeader);
compressCharArray(reply.content.c_str(), strlen(reply.content.c_str()), compressed, compressionType);
std::vector<unsigned char> compressed;
// double time = get_timestamp();
compressCharArray(reply.content.c_str(), strlen(reply.content.c_str()), compressed);
// std::cout << "[info] compression took " << get_timestamp() - time << " seconds." << std::endl;
reply.setSize(compressed.size()); reply.setSize(compressed.size());
std::vector<boost::asio::const_buffer> outputBuffer = reply.HeaderstoBuffers(); outputBuffer = reply.HeaderstoBuffers();
outputBuffer.push_back(boost::asio::buffer(compressed)); outputBuffer.push_back(boost::asio::buffer(compressed));
// std::cout << "[debug] outbuffer.size(): " << outputBuffer.size() << std::endl;
boost::asio::async_write(TCPsocket, outputBuffer, strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error))); boost::asio::async_write(TCPsocket, outputBuffer, strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));
break;
} else { case gzipRFC1952:
compressionHeader.name = "Content-Encoding";
compressionHeader.value = "gzip";
reply.headers.insert(reply.headers.begin(), compressionHeader);
compressCharArray(reply.content.c_str(), strlen(reply.content.c_str()), compressed, compressionType);
reply.setSize(compressed.size());
outputBuffer = reply.HeaderstoBuffers();
outputBuffer.push_back(boost::asio::buffer(compressed));
boost::asio::async_write(TCPsocket, outputBuffer, strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));break;
case noCompression:
boost::asio::async_write(TCPsocket, reply.toBuffers(), strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error))); boost::asio::async_write(TCPsocket, reply.toBuffers(), strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));
break;
} }
} else if (!result) { } else if (!result) {
@ -112,9 +121,7 @@ private:
// destructor closes the socket. // destructor closes the socket.
} }
void compressCharArray(const void *in_data, size_t in_data_size, std::vector<unsigned char> &buffer) { void compressCharArray(const void *in_data, size_t in_data_size, std::vector<unsigned char> &buffer, CompressionType type) {
// std::vector<unsigned char> buffer;
const size_t BUFSIZE = 128 * 1024; const size_t BUFSIZE = 128 * 1024;
unsigned char temp_buffer[BUFSIZE]; unsigned char temp_buffer[BUFSIZE];
@ -125,34 +132,38 @@ private:
strm.avail_in = in_data_size; strm.avail_in = in_data_size;
strm.next_out = temp_buffer; strm.next_out = temp_buffer;
strm.avail_out = BUFSIZE; strm.avail_out = BUFSIZE;
strm.data_type = Z_ASCII;
switch(type){
case deflateRFC1951:
deflateInit(&strm, Z_BEST_SPEED); deflateInit(&strm, Z_BEST_SPEED);
break;
while (strm.avail_in != 0) { case gzipRFC1952:
int res = deflate(&strm, Z_NO_FLUSH); /*
assert(res == Z_OK); * Big thanks to deusty who explains how to have gzip compression turned on by the right call to deflateInit2():
if (strm.avail_out == 0) { * http://deusty.blogspot.com/2007/07/gzip-compressiondecompression.html
buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE); */
strm.next_out = temp_buffer; deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, (15+16), 8, Z_DEFAULT_STRATEGY);
strm.avail_out = BUFSIZE; break;
} case noCompression:
std::cerr << "[error] contradicting compression request" << std::endl;
return;
} }
int deflate_res = Z_OK; int deflate_res = Z_OK;
while (deflate_res == Z_OK) { do {
if (strm.avail_out == 0) { if (strm.avail_out == 0) {
buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE); buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE);
strm.next_out = temp_buffer; strm.next_out = temp_buffer;
strm.avail_out = BUFSIZE; strm.avail_out = BUFSIZE;
} }
deflate_res = deflate(&strm, Z_FINISH); deflate_res = deflate(&strm, Z_FINISH);
}
} while (strm.avail_out == 0);
assert(deflate_res == Z_STREAM_END); assert(deflate_res == Z_STREAM_END);
buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE - strm.avail_out); buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE - strm.avail_out);
deflateEnd(&strm); deflateEnd(&strm);
// out_data.swap(buffer);
} }
boost::asio::io_service::strand strand; boost::asio::io_service::strand strand;

5
Server/RequestParser.h
View File

@ -164,10 +164,11 @@ private:
} else { } else {
state_ = header_name; state_ = header_name;
if(header.name == "Accept-Encoding") { if(header.name == "Accept-Encoding") {
/* giving gzip precedence over deflate */
if(header.value.find("deflate") != std::string::npos) if(header.value.find("deflate") != std::string::npos)
*compressionType = deflateRFC1951; *compressionType = deflateRFC1951;
// if(header.value.find("gzip") != std::string::npos) if(header.value.find("gzip") != std::string::npos)
// *compressionType = gzipRFC1952; *compressionType = gzipRFC1952;
} }
header.Clear(); header.Clear();
header.name.push_back(input); header.name.push_back(input);

1
Server/ServerFactory.h
View File

@ -75,6 +75,7 @@ struct ServerFactory {
if(atoi(serverConfig.GetParameter("Threads").c_str()) != 0 && (unsigned)atoi(serverConfig.GetParameter("Threads").c_str()) <= threads) if(atoi(serverConfig.GetParameter("Threads").c_str()) != 0 && (unsigned)atoi(serverConfig.GetParameter("Threads").c_str()) <= threads)
threads = atoi( serverConfig.GetParameter("Threads").c_str() ); threads = atoi( serverConfig.GetParameter("Threads").c_str() );
std::cout << "[info] http 1.1 compression handled by zlib version " << zlibVersion() << std::endl;
Server * server = new Server(serverConfig.GetParameter("IP"), serverConfig.GetParameter("Port"), threads); Server * server = new Server(serverConfig.GetParameter("IP"), serverConfig.GetParameter("Port"), threads);
return server; return server;
} }