We want to pass the response object (get from the server's callback function onRequest()) to the request handler through the request routing. The handler can then use the functions on the object to respond to the request.
Let's make changes to server.js first:
The code copy is as follows:
var http = require("http");
var url = require("url");
function start(route, handle) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
route(handle, pathname, response);
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
We pass the response object as the third parameter to the route() function, and we remove all the response call in the onRequest() handler because we want this part of the work to let the route() function complete.
Next, modify router.js:
The code copy is as follows:
function route(handle, pathname, response) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}
exports.route = route;
The same pattern: Compared to the previous acquisition of the return value from the request handler, this time instead, it is directly passed the response object. If there is no corresponding request processor to handle it, we will directly return the "404" error.
Next, modify requestHandler.js:
The code copy is as follows:
var exec = require("child_process").exec;
function start(response) {
console.log("Request handler 'start' was called.");
exec("ls -lah", function (error, stdout, stderr) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write(stdout);
response.end();
});
}
function upload(response) {
console.log("Request handler 'upload' was called.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello Upload");
response.end();
}
exports.start = start;
exports.upload = upload;
Our handler function needs to receive the response parameter in order to respond directly to the request. The start handler performs a request response operation in the anonymous callback function of exec(), while the upload handler still simply replying to "Hello World", but this time it is using the response object.
If you want to prove that the time-consuming operation in the /start handler will not block the immediate response to the /upload request, you can modify requestHandlers.js to the following form:
The code copy is as follows:
var exec = require("child_process").exec;
function start(response) {
console.log("Request handler 'start' was called.");
exec("find /",
{ timeout: 10000, maxBuffer: 20000*1024 },
function (error, stdout, stderr) {
response.writeHead(200, {"Content-Type": "text/plain"});
response.write(stdout);
response.end();
}
);
}
function upload(response) {
console.log("Request handler 'upload' was called.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello Upload");
response.end();
}
exports.start = start;
exports.upload = upload;
In this way, when requesting http://localhost:8888/start, it will take 10 seconds to load, and when requesting http://localhost:8888/upload, it will respond immediately, even if the /start response is still being processed at this time.