Static File Benchmark

file.js

var fs = require('fs'),
    http = require('http');

var FILE = 'foo.html',
    fileData,
    fileLength;

fs.readFile(FILE, function(err, d) {
  if (err) throw err;
  fileData = d;
  fileLength = fileData.length;
});

var server = http.createServer(function(req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'
                      , 'Content-Length': fileLength});
  res.end(fileData);
})

server.listen(8080, function(){
  console.log('Non Streaming Server Started');
});

PerfServer.java

/*                                                                                                                                                                                  
 * Copyright 2011 the original author or authors.                                                                                                                                   
 *                                                                                                                                                                                  
 * Licensed under the Apache License, Version 2.0 (the "License");                                                                                                                  
 * you may not use this file except in compliance with the License.                                                                                                                 
 * You may obtain a copy of the License at                                                                                                                                          
 *                                                                                                                                                                                  
 *      http://www.apache.org/licenses/LICENSE-2.0                                                                                                                                  
 *                                                                                                                                                                                  
 * Unless required by applicable law or agreed to in writing, software                                                                                                              
 * distributed under the License is distributed on an "AS IS" BASIS,                                                                                                                
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.                                                                                                         
 * See the License for the specific language governing permissions and                                                                                                              
 * limitations under the License.                                                                                                                                                   
 */                                                                                                                                                                                 
                                                                                                                                                                                    
package org.vertx.java.examples.httpperf;                                                                                                                                           
                                                                                                                                                                                    
import org.vertx.java.core.AsyncResult;                                                                                                                                             
import org.vertx.java.core.AsyncResultHandler;                                                                                                                                      
import org.vertx.java.core.Handler;                                                                                                                                                 
import org.vertx.java.core.buffer.Buffer;                                                                                                                                           
import org.vertx.java.core.http.HttpServerRequest;                                                                                                                                  
import org.vertx.java.deploy.Verticle;                                                                                                                                              
                                                                                                                                                                                    
public class PerfServer extends Verticle {                                                                                                                                          
                                                                                                                                                                                    
  public void start() {                                                                                                                                                             
    vertx.createHttpServer().requestHandler(new Handler<HttpServerRequest>() {                                                                                                      
      public void handle(final HttpServerRequest req) {                                                                                                                             
        // Just return OK                                                                                                                                                           
        //req.response.end();                                                                                                                                                       
                                                                                                                                                                                    
        // If you want to serve a real file uncomment this and comment previous line                                                                                                
        //req.response.sendFile("httpperf/foo.html");                                                                                                                               
        vertx.fileSystem().readFile("httpperf/foo.html", new AsyncResultHandler<Buffer>() {                                                                                         
          public void handle(AsyncResult<Buffer> ar) {                                                                                                                              
            req.response.putHeader("Content-Length", ar.result.length());                                                                                                           
            req.response.putHeader("Content-Type", "text/html");                                                                                                                    
            req.response.end(ar.result);                                                                                                                                            
          }                                                                                                                                                                         
        });                                                                                                                                                                         
      }                                                                                                                                                                             
    }).listen(8080, "localhost");                                                                                                                                                   
  }                                                                                                                                                                                 
}