Update routing to work and fix broken mongodb updates test

frameworks/JavaScript/nodejs/benchmark_config.json

@@ -22,9 +22,9 @@
     },
     "mongodb": {
       "setup_file": "setup",
-      "db_url": "/mongoose",
-      "query_url": "/mongoose?queries=",
-      "update_url": "/mongoose-update?queries=",
+      "db_url": "/mongoose/db",
+      "query_url": "/mongoose/queries?queries=",
+      "update_url": "/mongoose/updates?queries=",
       "port": 8080,
       "approach": "Realistic",
       "classification": "Platform",
@@ -42,9 +42,9 @@
     },
     "mongodb-raw": {
       "setup_file": "setup",
-      "db_url": "/mongodb",
-      "query_url": "/mongodb?queries=",
-      "update_url": "/mongodb-update?queries=",
+      "db_url": "/mongodb/db",
+      "query_url": "/mongodb/queries?queries=",
+      "update_url": "/mongodb/updates?queries=",
       "port": 8080,
       "approach": "Realistic",
       "classification": "Platform",
@@ -62,9 +62,9 @@
     },
     "mysql": {
       "setup_file": "setup",
-      "db_url": "/mysql-orm",
-      "query_url": "/mysql-orm?queries=",
-      "update_url": "/mysql-orm-update?queries=",
+      "db_url": "/mysql-orm/db",
+      "query_url": "/mysql-orm/queries?queries=",
+      "update_url": "/mysql-orm/updates?queries=",
       "port": 8080,
       "approach": "Realistic",
       "classification": "Platform",
@@ -82,9 +82,9 @@
     },
     "mysql-raw": {
       "setup_file": "setup",
-      "db_url": "/mysql",
-      "query_url": "/mysql?queries=",
-      "update_url": "/mysql-update?queries=",
+      "db_url": "/mysql/db",
+      "query_url": "/mysql/queries?queries=",
+      "update_url": "/mysql/updates?queries=",
       "port": 8080,
       "approach": "Realistic",
       "classification": "Platform",

frameworks/JavaScript/nodejs/hello.js

@@ -1,7 +1,3 @@
-/**
- * Module dependencies.
- */
-
 var cluster = require('cluster')
   , numCPUs = require('os').cpus().length
   , http = require('http')
@@ -10,18 +6,18 @@ var cluster = require('cluster')
   , mysql = require('mysql')
   , async = require('async')
   , mongoose = require('mongoose')
-  , conn = mongoose.connect('mongodb://localhost/hello_world')
+  , conn = mongoose.connect('mongodb://127.0.0.1/hello_world')
   , MongoClient = require('mongodb').MongoClient;
 
 // MongoDB Raw Setup
 var collection = null;
-MongoClient.connect('mongodb://localhost/hello_world?maxPoolSize=5', function(err, db) {
+MongoClient.connect('mongodb://127.0.0.1/hello_world?maxPoolSize=5', function(err, db) {
   collection = db.collection('world');
 });
 
 // MySQL Raw Setup
 var connection = mysql.createConnection({
-  host     : 'localhost',
+  host     : '127.0.0.1',
   user     : 'benchmarkdbuser',
   password : 'benchmarkdbpass',
   database : 'hello_world'
@@ -39,7 +35,7 @@ var WorldSchema = new mongoose.Schema({
 
 // Sequelize Setup
 var sequelize = new Sequelize('hello_world', 'benchmarkdbuser', 'benchmarkdbpass', {
-  host: 'localhost',
+  host: '127.0.0.1',
   dialect: 'mysql',
   logging: false
 });
@@ -55,23 +51,34 @@ var World = sequelize.define('World', {
   timestamps: false,
   freezeTableName: true
 });
-var Fortune = sequelize.define('Fortune', {
-  id: {
-    type: 'Sequelize.INTEGER'
-  },
-  message: {
-    type: 'Sequelize.STRING'
-  }
-}, {
-  timestamps: false,
-  freezeTableName: true
-});
+
+// No additional work on fortunes has been done
+//
+// var Fortune = sequelize.define('Fortune', {
+//   id: {
+//     type: 'Sequelize.INTEGER'
+//   },
+//   message: {
+//     type: 'Sequelize.STRING'
+//   }
+// }, {
+//   timestamps: false,
+//   freezeTableName: true
+// });
 
 // 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;
+}
+
 // Mongoose Query Functions
 function mongooseQuery(callback) {
   MWorld.findOne({
@@ -136,216 +143,274 @@ function mysqlUpdateQuery(callback) {
       callback(null, rows[0]);
     });
   });
-} 
+}
 
-if(cluster.isMaster) {
-  // Fork workers.
-  for (var i = 0; i < numCPUs; i++) {
-    cluster.fork();
-  }
+var GREETING = "Hello, World!";
+var HELLO_OBJ = { message: GREETING };
 
-  cluster.on('exit', function(worker, code, signal) {
-    console.log('worker ' + worker.pid + ' died');
-  });
+var responses = {
 
-  return;
-} else {
-  http.createServer(function (req, res) {
-    // JSON response object
-    var hello = {message: "Hello, World!"};
-    var helloStr = "Hello, World!";
-    var path = url.parse(req.url).pathname;
+  jsonSerialization: function (req, res) {
+    res.writeHead(200, {
+      'Content-Type': 'application/json',
+      'Server': 'Node'
+    });
+    res.end(JSON.stringify(HELLO_OBJ));
+  },
+
+  plaintext: function (req, res) {
+    res.writeHead(200, {
+      'Content-Type': 'text/plain; charset=UTF-8',
+      'Server': 'Node'
+    });
+    res.end(GREETING);
+  },
 
-    switch (req.url) {
-      case '/json':
+  mongooseSingleQuery: function (req, res) {
+    mongooseQuery(function (err, result) {
+      if (err) { throw err; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json; charset=UTF-8',
+        'Server': 'Node'
+      });
+      res.end(JSON.stringify(result));
+    })
+  },
+
+  mongooseMultipleQueries: function (queries, req, res) {
+    var queryFunctions = fillArray(mongooseQuery, queries)
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  mongooseUpdates: function (queries, req, res) {
+    var selectFunctions = fillArray(mongooseQuery, 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();
+            MWorld.update({
+              id: worlds[i].id
+            }, {
+              randomNumber: worlds[i].randomNumber
+            }, callback);
+          });
+        })(i);
+      }
+
+      async.parallel(updateFunctions, function (err, results) {
+        if (err) { throw err; }
         res.writeHead(200, {
           'Content-Type': 'application/json',
           'Server': 'Node'
         });
-        res.end(JSON.stringify(hello));
-        break;
+        // results does not have updated document information
+        // if no err was found and thrown, updates were all successful
+        res.end(JSON.stringify(worlds));
+      });
+    });
+  },
+
+  mongodbSingleQuery: function (req, res) {
+    mongodbDriverQuery(function (err, result) {
+      if (err) { throw err; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      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; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  mongodbUpdates: function (queries, req, res) {
+    var queryFunctions = fillArray(mongodbDriverUpdateQuery, queries);
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  sequelizeSingleQuery: function (req, res) {
+    sequelizeQuery(function (err, result) {
+      if (err) { throw err; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      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; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  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);
+      }
 
-      case '/plaintext':
+      async.parallel(updateFunctions, function (err, updates) {
+        if (err) { throw err; }
         res.writeHead(200, {
-          'Content-Type': 'text/plain; charset=UTF-8',
+          'Content-Type': 'application/json',
           'Server': 'Node'
         });
-        res.end(helloStr);
-        break;
-    }
+        res.end(JSON.stringify(updates));
+        // res.end(JSON.stringify(worlds));
+      });
+    });
+  },
+
+  mysqlSingleQuery: function (req, res) {
+    mysqlQuery(function (err, result) {
+      if (err) { throw err; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      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; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      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; }
+      res.writeHead(200, {
+        'Content-Type': 'application/json',
+        'Server': 'Node'
+      });
+      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 queries = isNaN(values.query.queries) ? 1 : parseInt(values.query.queries, 10);
-    queries = Math.min(Math.max(queries, 1), 500);
-    switch (values.pathname) {
-      // Raw MongoDB Routes
-      case '/mongodb':
-        var queryFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          queryFunctions.push(mongodbDriverQuery);
-        }
-
-        async.parallel(queryFunctions, function(err, results) {
-          if (!values.query.queries) {
-            results = results[0];
-          }
-          res.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Server': 'Node'
-          });
-          res.end(JSON.stringify(results));
-        });
-        break;
-
-      case '/mongodb-update':
-        var queryFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          queryFunctions.push(mongodbDriverUpdateQuery);
-        }
-
-        async.parallel(queryFunctions, function(err, results) {
-          res.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Server': 'Node'
-          });
-          res.end(JSON.stringify(results));
-        });
-        break;
-
-      // Mongoose ORM Routes
-      case '/mongoose':
-        var queryFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          queryFunctions.push(mongooseQuery);
-        }
-
-        async.parallel(queryFunctions, function(err, results) {
-          if (!values.query.queries) {
-            results = results[0];
-          }
-          res.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Server': 'Node'
-          });
-          res.end(JSON.stringify(results));
-        });
-        break;
-
-      case '/mongoose-update':
-        var selectFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          selectFunctions.push(mongooseQuery);
-        }
-
-        async.parallel(selectFunctions, function(err, worlds) {
-          var updateFunctions = [];
-
-          for (var i = 0; i < queries; i++) {
-            (function(i){
-              updateFunctions.push(function(callback){
-                worlds[i].randomNumber = Math.ceil(Math.random() * 10000);
-                MWorld.update({
-                  id: worlds[i]
-                }, {
-                  randomNumber: worlds[i].randomNumber
-                }, callback);
-              });
-            })(i);
-          }
-
-          async.parallel(updateFunctions, function(err, updates) {
-            res.writeHead(200, {
-              'Content-Type': 'application/json',
-              'Server': 'Node'
-            });
-            res.end(JSON.stringify(worlds));
-          });
-        });
-        break;
-
-      // Sequelize (MySQL ORM) Routes
-      case '/mysql-orm':
-        var queryFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          queryFunctions.push(sequelizeQuery);
-        }
-
-        async.parallel(queryFunctions, function(err, results) {
-          if (!values.query.queries) {
-            results = results[0];
-          }
-          res.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Server': 'Node'
-          });
-          res.end(JSON.stringify(results));
-        });
-        break;
-
-      case '/mysql-orm-update':
-        var selectFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          selectFunctions.push(sequelizeQuery);
-        }
-
-        async.parallel(selectFunctions, function(err, worlds) {
-          var updateFunctions = [];
-
-          for (var i = 0; i < queries; i++) {
-            (function(i){
-              updateFunctions.push(function(callback){
-                worlds[i].randomNumber = Math.ceil(Math.random() * 10000);
-                worlds[i].save().complete(callback);
-              });
-            })(i);
-          }
-
-          async.parallel(updateFunctions, function(err, updates) {
-            res.writeHead(200, {
-              'Content-Type': 'application/json',
-              'Server': 'Node'
-            });
-            res.end(JSON.stringify(worlds));
-          });
-        });
-        break;
-
-      // Raw MongoDB Routes
-      case '/mysql':
-        var queryFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          queryFunctions.push(mysqlQuery);
-        }
-
-        async.parallel(queryFunctions, function(err, results) {
-          if (!values.query.queries) {
-            results = results[0];
-          }
-          res.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Server': 'Node'
-          });
-          res.end(JSON.stringify(results));
-        });
-        break;
-
-      case '/mysql-update':
-        var queryFunctions = [];
-        for (var i = 0; i < queries; i += 1) {
-          queryFunctions.push(mysqlUpdateQuery);
-        }
-        async.parallel(queryFunctions, function(err, results) {
-          res.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Server': 'Node'
-          });
-          res.end(JSON.stringify(results));
-        });
-        break;
+    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 === '/mongodb/db') {
+      return responses.mongodbSingleQuery(req, res);
+    } else if (route === '/mysql-orm/db') {
+      return responses.sequelizeSingleQuery(req, res);
+    } else if (route === '/mysql/db') {
+      return responses.mysqlSingleQuery(req, res);
+    }
 
-      default:
-        // File not found handler
-        res.writeHead(501, {'Content-Type': 'text/plain; charset=UTF-8'});
-        res.end("NOT IMPLEMENTED");
+    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 === '/mysql-orm/queries') {
+        return responses.sequelizeMultipleQueries(queries, req, res);
+      } else if (route === '/mysql-orm/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);
+    }
+  }).listen(8080, function() {
+    console.log("NodeJS worker listening on port 8080");
+  });
 }