compsci-industry
/
TechEmpower.FrameworkBenchmarks
mirror of https://github.com/TechEmpower/FrameworkBenchmarks.git


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488
							var cluster = require('cluster')
  , numCPUs = require('os').cpus().length
  , http = require('http')
  , url = require('url')
  , Sequelize = require('sequelize')
  , mysql = require('mysql')
  , async = require('async')
  , Mongoose = require('mongoose')
  , conn = Mongoose.connect('mongodb://127.0.0.1/hello_world')
  , MongoClient = require('mongodb').MongoClient
  , Handlebars = require('handlebars');

// MongoDB Raw Setup
var mongodbCollections = {
  World: null,
  Fortune: null
};
MongoClient.connect('mongodb://127.0.0.1/hello_world?maxPoolSize=5', function (err, db) {
  if (err) { throw err; }
  mongodbCollections.World = db.collection('world');
  mongodbCollections.Fortune = db.collection('fortune');
});

// MySQL Raw Setup
var connection = mysql.createConnection({
  host     : '127.0.0.1',
  user     : 'benchmarkdbuser',
  password : 'benchmarkdbpass',
  database : 'hello_world'
});
connection.connect();

// Mongoose Setup
var WorldSchema = new Mongoose.Schema({
    id          : Number,
    randomNumber: Number
  }, {
    collection: 'world'
  });
var FortuneSchema = new Mongoose.Schema({
    id:      Number,
    message: String
  }, {
    collection: 'fortune'
  });
var mongoose = {
  World:   conn.model('World', WorldSchema),
  Fortune: conn.model('Fortune', FortuneSchema)
}


// Sequelize Setup
var sequelize = new Sequelize('hello_world', 'benchmarkdbuser', 'benchmarkdbpass', {
  host: '127.0.0.1',
  dialect: 'mysql',
  logging: false
});

var World = sequelize.define('World', {
  id: {
    type: 'Sequelize.INTEGER'
  },
  randomNumber: {
    type: 'Sequelize.INTEGER'
  }
}, {
  timestamps: false,
  freezeTableName: true
});

var Fortune = sequelize.define('Fortune', {
  id: {
    type: 'Sequelize.INTEGER'
  },
  message: {
    type: 'Sequelize.STRING'
  }
}, {
  timestamps: false,
  freezeTableName: true
});

// Fortunes template via handlebars setup
var fortunesTemplate = Handlebars.compile([
  "<!DOCTYPE html>",
  "<html>",
  "<head><title>Fortunes</title></head>",
  "<body>",
  "<table>",
    "<tr>",
      "<th>id</th>",
      "<th>message</th>",
    "</tr>",
    "{{#fortunes}}",
    "<tr>",
      "<td>{{id}}</td>",
      "<td>{{message}}</td>",
    "</tr>",
    "{{/fortunes}}",
  "</table>",
  "</body>",
  "</html>"
].join(''));

// Helper functions
function getRandomNumber() {
  return Math.floor(Math.random() * 10000) + 1;
}

function fillArray(value, len) {
  var arr = [];
  for (var i = 0; i < len; i++) {
    arr.push(value);
  }
  return arr;
}

function addTfbHeaders(res, headerType) {
  var headers = {
    'Server': 'Node'
  }

  if (headerType === 'plain') {
    headers['Content-Type'] = 'text/plain; charset=UTF-8';
  } else if (headerType === 'json') {
    headers['Content-Type'] = 'application/json';
  } else if (headerType === 'html') {
    headers['Content-Type'] = 'text/html; cherset=UTF-8';
  }

  res.writeHead(200, headers);
}

// Mongoose Query Functions
function mongooseRandomWorld(callback) {
  mongoose.World.findOne({
    id: getRandomNumber()
  }).exec(function (err, world) {
    callback(err, world);
  });
}

function mongooseGetAllFortunes(callback) {
  mongoose.Fortune.find({}).exec(function (err, fortunes) {
    callback(err, fortunes);
  });
}

// MongoDB-Raw Query Functions
function mongodbDriverQuery(callback) {
  mongodbCollections.World.findOne({
    id: getRandomNumber()
  }, function(err, world) {
    world._id = undefined; // remove _id from query response
    callback(err, world);
  });
}

function mongodbGetAllFortunes(callback) {
  mongodbCollections.Fortune.find().toArray(function (err, fortunes) {
    callback(err, fortunes);
  })
}

function mongodbDriverUpdateQuery(callback) {
  mongodbCollections.World.findAndModify({
    id: getRandomNumber()
  }, [['_id','asc']], {
    $set: {randomNumber: getRandomNumber()}
  }, {}, function(err, world) {
    world.value._id = undefined; // remove _id from query response
    callback(err, world.value);
  });
}

// Sequelize Query Functions
function sequelizeQuery(callback) {
  World.findOne({
    where: {
      id: Math.floor(Math.random() * 10000) + 1}
    }
  ).complete(callback);
}


// MySQL-Raw Query Functions
function mysqlQuery(callback) {
  connection.query("SELECT * FROM world WHERE id = " + getRandomNumber(), function (err, rows, fields) {
    if (err) {
      throw err;
    }
    callback(null, rows[0]);
  });
}

function mysqlUpdateQuery(callback) {
  connection.query("SELECT * FROM world WHERE id = " + getRandomNumber(), function (err, rows, fields) {
    if (err) {
      throw err;
    }
    rows[0].randomNumber = getRandomNumber();
    var updateQuery = "UPDATE world SET randomNumber = " + rows[0].randomNumber + " WHERE id = " + rows[0]['id'];
    connection.query(updateQuery, function (err, result) {
      if (err) {
        throw err;
      }
      callback(null, rows[0]);
    });
  });
}

var GREETING = "Hello, World!";
var HELLO_OBJ = { message: GREETING };
var ADDITIONAL_FORTUNE = {
  id: 0,
  message: 'Additional fortune added at request time.'
};

var responses = {

  jsonSerialization: function (req, res) {
    addTfbHeaders(res, 'json');
    res.end(JSON.stringify(HELLO_OBJ));
  },

  plaintext: function (req, res) {
    addTfbHeaders(res, 'plain');
    res.end(GREETING);
  },

  mongooseSingleQuery: function (req, res) {
    mongooseRandomWorld(function (err, result) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(result));
    })
  },

  mongooseMultipleQueries: function (queries, req, res) {
    var queryFunctions = fillArray(mongooseRandomWorld, queries)

    async.parallel(queryFunctions, function (err, results) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(results));
    });
  },

  mongooseFortunes: function (req, res) {
    mongooseGetAllFortunes(function (err, fortunes) {
      if (err) { throw err; }
      fortunes.push(ADDITIONAL_FORTUNE);
      fortunes.sort(function (a, b) {
        return a.message.localeCompare(b.message);
      });
      addTfbHeaders(res, 'html');
      res.end(fortunesTemplate({
        fortunes: fortunes
      }))
    });
  },

  mongooseUpdates: function (queries, req, res) {
    var selectFunctions = fillArray(mongooseRandomWorld, queries);

    async.parallel(selectFunctions, function (err, worlds) {
      var updateFunctions = [];

      for (var i = 0; i < queries; i++) {
        (function (i) {
          updateFunctions.push(function (callback) {
            worlds[i].randomNumber = getRandomNumber();
            mongoose.World.update({
              id: worlds[i].id
            }, {
              randomNumber: worlds[i].randomNumber
            }, callback);
          });
        })(i);
      }

      async.parallel(updateFunctions, function (err, results) {
        if (err) { throw err; }
        addTfbHeaders(res, 'json');
        // results does not have updated document information
        // if no err was found and thrown: all updates succeeded
        res.end(JSON.stringify(worlds));
      });
    });
  },

  mongodbSingleQuery: function (req, res) {
    mongodbDriverQuery(function (err, result) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(result));
    });
  },

  mongodbMultipleQueries: function (queries, req, res) {
    var queryFunctions = fillArray(mongodbDriverQuery, queries);

    async.parallel(queryFunctions, function (err, results) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(results));
    });
  },

  mongodbFortunes: function (req, res) {
    mongodbGetAllFortunes(function (err, fortunes) {
      if (err) { throw err; }
      fortunes.push(ADDITIONAL_FORTUNE);
      fortunes.sort(function (a, b) {
        return a.message.localeCompare(b.message);
      });
      addTfbHeaders(res, 'html');
      res.end(fortunesTemplate({
        fortunes: fortunes
      }));
    });
  },

  mongodbUpdates: function (queries, req, res) {
    var queryFunctions = fillArray(mongodbDriverUpdateQuery, queries);

    async.parallel(queryFunctions, function (err, results) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(results));
    });
  },

  sequelizeSingleQuery: function (req, res) {
    sequelizeQuery(function (err, result) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(result));
    });
  },

  sequelizeMultipleQueries: function (queries, req, res) {
    var queryFunctions = fillArray(sequelizeQuery, queries);

    async.parallel(queryFunctions, function (err, results) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(results));
    });
  },

  sequelizeFortunes: function (req, res) {
    Fortune.findAll().complete(function (err, fortunes) {
      fortunes.push(ADDITIONAL_FORTUNE);
      fortunes.sort(function (a, b) {
        return a.message.localeCompare(b.message);
      });
      addTfbHeaders(res, 'html');
      res.end(fortunesTemplate({
        fortunes: fortunes
      }));
    });
  },

  sequelizeUpdates: function (queries, req, res) {
    var selectFunctions = fillArray(sequelizeQuery, queries);

    async.parallel(selectFunctions, function (err, worlds) {
      var updateFunctions = [];

      for (var i = 0; i < queries; i++) {
        (function (i) {
          updateFunctions.push(function (callback) {
            worlds[i].randomNumber = getRandomNumber();
            worlds[i].save().complete(callback);
          });
        })(i);
      }

      async.parallel(updateFunctions, function (err, updates) {
        if (err) { throw err; }
        addTfbHeaders(res, 'json');
        res.end(JSON.stringify(updates));
      });
    });
  },

  mysqlSingleQuery: function (req, res) {
    mysqlQuery(function (err, result) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(result));
    });
  },

  mysqlMultipleQueries: function (queries, req, res) {
    var queryFunctions = fillArray(mysqlQuery, queries);

    async.parallel(queryFunctions, function (err, results) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(results));
    });
  },

  mysqlUpdates: function (queries, req, res) {
    var queryFunctions = fillArray(mysqlUpdateQuery, queries);

    async.parallel(queryFunctions, function (err, results) {
      if (err) { throw err; }
      addTfbHeaders(res, 'json');
      res.end(JSON.stringify(results));
    });
  },

  routeNotImplemented: function (req, res) {
    res.writeHead(501, {'Content-Type': 'text/plain; charset=UTF-8'});
    var reason = { reason: "`" + req.url + "` is not an implemented route" };
    res.end(JSON.stringify(reason));
  }

};

if (cluster.isMaster) {
  // Fork workers.
  for (var i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', function (worker, code, signal) {
    console.log('worker ' + worker.pid + ' died');
  });
} else {
  http.createServer(function (req, res) {
    var values = url.parse(req.url, true);
    var route = values.pathname;

    // Basic routes, no db required
    if (route === '/json') {
      return responses.jsonSerialization(req, res);
    } else if (route === '/plaintext') {
      return responses.plaintext(req, res);

    // No queries parameter required
    } else if (route === '/mongoose/db') {
      return responses.mongooseSingleQuery(req, res);
    } else if (route === '/mongoose/fortunes') {
      return responses.mongooseFortunes(req, res);
    } else if (route === '/mongodb/db') {
      return responses.mongodbSingleQuery(req, res);
    } else if (route === '/mongodb/fortunes') {
      return responses.mongodbFortunes(req, res);
    } else if (route === '/sequelize/db') {
      return responses.sequelizeSingleQuery(req, res);
    } else if (route === '/sequelize/fortunes') {
      return responses.sequelizeFortunes(req, res);
    } else if (route === '/mysql/db') {
      return responses.mysqlSingleQuery(req, res);
    }

    else {
      var queries = isNaN(values.query.queries) ? 1 : parseInt(values.query.queries, 10);
      queries = Math.min(Math.max(queries, 1), 500);

      if (route === '/mongoose/queries') {
        return responses.mongooseMultipleQueries(queries, req, res);
      } else if (route === '/mongoose/updates') {
        return responses.mongooseUpdates(queries, req, res);
      } else if (route === '/mongodb/queries') {
        return responses.mongodbMultipleQueries(queries, req, res);
      } else if (route === '/mongodb/updates') {
        return responses.mongodbUpdates(queries, req, res);
      } else if (route === '/sequelize/queries') {
        return responses.sequelizeMultipleQueries(queries, req, res);
      } else if (route === '/sequelize/updates') {
        return responses.sequelizeUpdates(queries, req, res);
      } else if (route === '/mysql/queries') {
        return responses.mysqlMultipleQueries(queries, req, res);
      } else if (route === '/mysql/updates') {
        return responses.mysqlUpdates(queries, req, res);
      } else {
        return responses.routeNotImplemented(req, res);
      }
    }
  }).listen(8080, function() {
    console.log("NodeJS worker listening on port 8080");
  });
}