Use Node. js to develop a reverse proxy server for memcache Protocol

Memcache is a common key-value cache solution, and its Protocol is also used in the nosql database tokyo tyrant.

In actual projects, for load balancing and other considerations, clients such as php and java need to access multiple memcache and map a request for a specific key to a specific memcache. In this way, you need to configure multiple IP addresses on each client and implement the map algorithm, which is not easy to manage and maintain. Recently, I learned about node. js, so I decided to use node. js to build a reverse proxy for node. js. Implements the same protocol as memcache for clients such as php and java. Forward client requests to several backend memcache instances based on the request key values.

Node is developed based on v8 and libevent. The main idea is to use single thread + event loop to Implement Asynchronous io servers. This mode is similar to nginx, which is faster than traditional multi-process (such as apache prefork mode) or thread (such as tomcat and other app server.

There are many complicated factors to consider when implementing pure asynchronous I/O servers, and debugging is difficult if errors occur. Using node can free you from tedious memory processing and other underlying work, and focus on your core models and application logic.

It is very easy to use node to implement a socket server. The following code can implement a simple echo server:

 
 

  
  
Server = net. createServer (
  
  
Function (socket ){
  
  
Socket. on ('data', function (data ){
  
  
// This is socket.
  
  
This. write (data );
  
  
});
  
  
}
  
  
). Listen (port_number );
 
 

Because I want to receive and distribute memcache requests based on the request key value, I need to parse the received data. Then, the request key determines which memcache is used and writes the request to the memcache connection. When the memcache connection receives data, it writes the data back to the client socket, and the basic process of the proxy ends.

 
 

  
  
socket.on('data',function(data){  
  
  
        var request=mk_request(data);  
  
  
        var mc=create_memcache_conn(request.key);  
  
  
        mc.write(request);  
  
  
        mc.on('data',function(data){  
  
  
                socket.write(data);  
  
  
            });  
  
  
    }); 
 
 

It is worth noting that due to the asynchronous feature of node, it is possible to receive less data than one request, or more data than one request, or contain several requests, the remaining data must be added to the data received next time to ensure that there is no problem in receiving requests. The program is modified to the following structure:

 
 

  
  
Function process_request (socket, request ){
  
  
Var mc = create_memcache_conn (request. key );
  
  
Mc. write (request );
  
  
Mc. on ('data', function (data ){
  
  
Socket. write (data );
  
  
});
  
  

  
  
}
  
  

  
  
Socket. on ('data', function (data ){
  
  
Do {
  
  
// Merge the remaining data with the new data
  
  
Data = new Buffer (this. remain_data, data );
  
  
// If the mk_request does not parse a complete request, false is returned.
  
  
Var request = mk_request (data );
  
  
This. remain_data = data. slice (request = false? 0: request. length );
  
  
Process_request (this, request );
  
  
} While (request );
  
  

  
  
});
 
 

However, the test results are still problematic. This is because the client may send multiple requests to the server at a time. When the server uses multiple memcache connections to process these requests and writes them back to the client in the ondata of the memcache connection, it cannot be ensured that the write-back sequence is consistent with the request sequence, resulting in an error. Therefore, a queue is required to ensure the order of data written back.

 
 

  
  
Function process_request (socket, request ){
  
  
Var mc = create_memcache_conn (request. key );
  
  
Mc. write (request );
  
  
Mc. queue. push ({req: request, res: false });
  
  
Mc. on ('data', function (data ){
  
  
// Receiving memcache responses are the same as receiving client requests, and may receive half of the requests at a time.
  
  
Data = new Buffer (this. remain_data, data );
  
  
// If mk_response does not parse a complete response, false is returned.
  
  
Var response = mk_response (data );
  
  
If (response ){
  
  
// After receiving a response, add the response to the queue
  
  
For (var I = 0; i0 ){
  
  
If (socket. queue [0]. res ){
  
  
Socket. write (socket. queue. shift (). res. buffer );
  
  
} Else {
  
  
Break;
  
  
}
  
  
}
  
  
This. removeListener ('data', arguments. callee );
  
  
}
  
  
});
  
  
}
 
 

In addition, the mk_request and mk_response functions need to be implemented, and the implementation is based on the memcache protocol. For my implementation, refer to the article: memcache protocol Chinese Version http://www.ccvita.com/306.html), memcache protocol is relatively simple.

In the final implementation, I also added the memcache connection pool function because it takes a long time to establish a memcache connection. We recommend that you maintain a persistent connection with the server in the memcache documentation, to speed up efficiency.

After joining the connection pool, I did a simple stress test. On a general laptop, there are dozens of processes concurrently, and there are no problems with the number of times per second. You can adjust the number to w.

Complete code please see my github Source: https://github.com/wwwppp0801/nodeproxy

Reference:

Memcache protocol (http://www.ccvita.com/306)

Node. js documentation: http://nodejs.org/docs/v0.4.7/api

Original article: http://blog.webshuo.com/2011/05/13/%E7%94%A8node-js%E5%BC%80%E5%8F%91memcache%E5%8D%8F%E8% AE % AE %E7%9A%84%E5%8F%8D%E5%90%91%E4%BB%A3%E7%90%86%E6%9C%8D%E5%8A%A1%E5%99%A8/