Refactor handlers out of main script

frameworks/JavaScript/nodejs/handlers/mongodb-raw.js

@@ -0,0 +1,84 @@
+var h = require('../helper');
+var async = require('async')
+var MongoClient = require('mongodb').MongoClient;
+var collections = {
+  World: null,
+  Fortune: null
+};
+MongoClient.connect('mongodb://127.0.0.1/hello_world?maxPoolSize=5', function (err, db) {
+  if (err) { throw err; }
+  collections.World = db.collection('world');
+  collections.Fortune = db.collection('fortune');
+});
+
+function mongodbRandomWorld(callback) {
+  collections.World.findOne({
+    id: h.randomTfbNumber()
+  }, function (err, world) {
+    world._id = undefined; // remove _id from query response
+    callback(err, world);
+  });
+}
+
+function mongodbGetAllFortunes(callback) {
+  collections.Fortune.find().toArray(function (err, fortunes) {
+    callback(err, fortunes);
+  })
+}
+
+function mongodbDriverUpdateQuery(callback) {
+  collections.World.findAndModify({
+    id: h.randomTfbNumber()
+  }, [['_id','asc']], {
+    $set: {randomNumber: h.randomTfbNumber()}
+  }, {}, function(err, world) {
+    world.value._id = undefined; // remove _id from query response
+    callback(err, world.value);
+  });
+}
+
+module.exports = {
+
+  SingleQuery: function (req, res) {
+    mongodbRandomWorld(function (err, result) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(result));
+    });
+  },
+
+  MultipleQueries: function (queries, req, res) {
+    var queryFunctions = h.fillArray(mongodbRandomWorld, queries);
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  Fortunes: function (req, res) {
+    mongodbGetAllFortunes(function (err, fortunes) {
+      if (err) { throw err; }
+      fortunes.push(h.ADDITIONAL_FORTUNE);
+      fortunes.sort(function (a, b) {
+        return a.message.localeCompare(b.message);
+      });
+      h.addTfbHeaders(res, 'html');
+      res.end(h.fortunesTemplate({
+        fortunes: fortunes
+      }));
+    });
+  },
+
+  Updates: function (queries, req, res) {
+    var queryFunctions = h.fillArray(mongodbDriverUpdateQuery, queries);
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(results));
+    });
+  }
+
+};

frameworks/JavaScript/nodejs/handlers/mongoose.js

@@ -0,0 +1,101 @@
+var h = require('../helper');
+var async = require('async');
+var Mongoose = require('mongoose');
+var connection = Mongoose.connect('mongodb://127.0.0.1/hello_world')
+
+// 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 Worlds = connection.model('World', WorldSchema);
+var Fortunes = connection.model('Fortune', FortuneSchema);
+
+function mongooseRandomWorld(callback) {
+  Worlds.findOne({
+    id: h.randomTfbNumber()
+  }).exec(function (err, world) {
+    callback(err, world);
+  });
+}
+
+function mongooseGetAllFortunes(callback) {
+  Fortunes.find({}).exec(function (err, fortunes) {
+    callback(err, fortunes);
+  });
+}
+
+module.exports = {
+
+  SingleQuery: function (req, res) {
+    mongooseRandomWorld(function (err, result) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(result));
+    })
+  },
+
+  MultipleQueries: function (queries, req, res) {
+    var queryFunctions = h.fillArray(mongooseRandomWorld, queries)
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  Fortunes: function (req, res) {
+    mongooseGetAllFortunes(function (err, fortunes) {
+      if (err) { throw err; }
+      fortunes.push(h.ADDITIONAL_FORTUNE);
+      fortunes.sort(function (a, b) {
+        return a.message.localeCompare(b.message);
+      });
+      h.addTfbHeaders(res, 'html');
+      res.end(h.fortunesTemplate({
+        fortunes: fortunes
+      }))
+    });
+  },
+
+  Updates: function (queries, req, res) {
+    var selectFunctions = h.fillArray(mongooseRandomWorld, queries);
+
+    async.parallel(selectFunctions, function (err, worlds) {
+      if (err) { throw err; }
+      var updateFunctions = [];
+
+      for (var i = 0; i < queries; i++) {
+        (function (i) {
+          updateFunctions.push(function (callback) {
+            worlds[i].randomNumber = h.randomTfbNumber();
+            Worlds.update({
+              id: worlds[i].id
+            }, {
+              randomNumber: worlds[i].randomNumber
+            }, callback);
+          });
+        })(i);
+      }
+
+      async.parallel(updateFunctions, function (err, results) {
+        if (err) { throw err; }
+        h.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));
+      });
+    });
+  }
+
+};

frameworks/JavaScript/nodejs/handlers/mysql-raw.js

@@ -0,0 +1,94 @@
+var h = require('../helper');
+var async = require('async');
+var mysql = require('mysql');
+var connection = mysql.createConnection({
+  host     : '127.0.0.1',
+  user     : 'benchmarkdbuser',
+  password : 'benchmarkdbpass',
+  database : 'hello_world'
+});
+
+connection.connect();
+
+var queries = {
+  RANDOM_WORLD: "SELECT * FROM world WHERE id = " + h.randomTfbNumber(),
+  ALL_FORTUNES: "SELECT * FROM fortune",
+  UPDATE_WORLD: function (rows) {
+    return [
+      "UPDATE world SET randomNumber = ", rows[0].randomNumber,
+      " WHERE id = ", rows[0]['id']
+    ].join('');
+  }
+}
+
+function mysqlRandomWorld(callback) {
+  connection.query(queries.RANDOM_WORLD, function (err, rows, fields) {
+    if (err) { throw err; }
+    callback(null, rows[0]);
+  });
+}
+
+function mysqlGetAllFortunes(callback) {
+  connection.query(queries.ALL_FORTUNES, function (err, rows, fields) {
+    if (err) { throw err; }
+    callback(null, rows);
+  })
+}
+
+function mysqlUpdateQuery(callback) {
+  connection.query(queries.RANDOM_WORLD, function (err, rows, fields) {
+    if (err) { throw err; }
+    rows[0].randomNumber = h.randomTfbNumber();
+    var updateQuery = queries.UPDATE_WORLD(rows);
+    connection.query(updateQuery, function (err, result) {
+      if (err) { throw err; }
+      callback(null, rows[0]);
+    });
+  });
+}
+
+module.exports = {
+
+  SingleQuery: function (req, res) {
+    mysqlRandomWorld(function (err, result) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(result));
+    });
+  },
+
+  MultipleQueries: function (queries, req, res) {
+    var queryFunctions = h.fillArray(mysqlRandomWorld, queries);
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  Fortunes: function (req, res) {
+    mysqlGetAllFortunes(function (err, fortunes) {
+      if (err) { throw err; }
+      fortunes.push(h.ADDITIONAL_FORTUNE);
+      fortunes.sort(function (a, b) {
+        return a.message.localeCompare(b.message);
+      })
+      h.addTfbHeaders(res, 'html');
+      res.end(h.fortunesTemplate({
+        fortunes: fortunes
+      }));
+    })
+  },
+
+  Updates: function (queries, req, res) {
+    var queryFunctions = h.fillArray(mysqlUpdateQuery, queries);
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(results));
+    });
+  } 
+
+}

frameworks/JavaScript/nodejs/handlers/sequelize.js

@@ -0,0 +1,90 @@
+var h = require('../helper');
+var async = require('async');
+var Sequelize = require('sequelize');
+var sequelize = new Sequelize('hello_world', 'benchmarkdbuser', 'benchmarkdbpass', {
+  host: '127.0.0.1',
+  dialect: 'mysql',
+  logging: false
+});
+
+var Worlds = sequelize.define('World', {
+  id:           { type: 'Sequelize.INTEGER' },
+  randomNumber: { type: 'Sequelize.INTEGER' }
+}, {
+  timestamps: false,
+  freezeTableName: true
+});
+
+var Fortunes = sequelize.define('Fortune', {
+  id:      { type: 'Sequelize.INTEGER' },
+  message: { type: 'Sequelize.STRING' }
+}, {
+  timestamps: false,
+  freezeTableName: true
+});
+
+// Sequelize Query Functions
+function sequelizeRandomWorld(callback) {
+  Worlds.findOne({
+    where: { id: h.randomTfbNumber() }
+  }).complete(callback);
+}
+
+module.exports = {
+
+  SingleQuery: function (req, res) {
+    sequelizeRandomWorld(function (err, result) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(result));
+    });
+  },
+
+  MultipleQueries: function (queries, req, res) {
+    var queryFunctions = h.fillArray(sequelizeRandomWorld, queries);
+
+    async.parallel(queryFunctions, function (err, results) {
+      if (err) { throw err; }
+      h.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(results));
+    });
+  },
+
+  Fortunes: function (req, res) {
+    Fortunes.findAll().complete(function (err, fortunes) {
+      fortunes.push(h.ADDITIONAL_FORTUNE);
+      fortunes.sort(function (a, b) {
+        return a.message.localeCompare(b.message);
+      });
+      h.addTfbHeaders(res, 'html');
+      res.end(h.fortunesTemplate({
+        fortunes: fortunes
+      }));
+    });
+  },
+
+  Updates: function (queries, req, res) {
+    var selectFunctions = h.fillArray(sequelizeRandomWorld, queries);
+
+    async.parallel(selectFunctions, function (err, worlds) {
+      if (err) { throw err; }
+      var updateFunctions = [];
+
+      for (var i = 0; i < queries; i++) {
+        (function (i) {
+          updateFunctions.push(function (callback) {
+            worlds[i].randomNumber = h.randomTfbNumber();
+            worlds[i].save().complete(callback);
+          });
+        })(i);
+      }
+
+      async.parallel(updateFunctions, function (err, updates) {
+        if (err) { throw err; }
+        h.addTfbHeaders(res, 'json');
+        res.end(JSON.stringify(updates));
+      });
+    });
+  }
+
+}

frameworks/JavaScript/nodejs/hello.js

@@ -1,442 +1,19 @@
 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');
+  , url = require('url');
 
-// 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');
-});
+var h = require('./helper.js');
 
-// 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 mongodbRandomWorld(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 mysqlRandomWorld(callback) {
-  connection.query("SELECT * FROM world WHERE id = " + getRandomNumber(), function (err, rows, fields) {
-    if (err) { throw err; }
-    callback(null, rows[0]);
-  });
-}
-
-function mysqlGetAllFortunes(callback) {
-  connection.query("SELECT * FROM fortune", function (err, rows, fields) {
-    if (err) { throw err; }
-    callback(null, rows);
-  })
-}
-
-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) {
-    mongodbRandomWorld(function (err, result) {
-      if (err) { throw err; }
-      addTfbHeaders(res, 'json');
-      res.end(JSON.stringify(result));
-    });
-  },
-
-  mongodbMultipleQueries: function (queries, req, res) {
-    var queryFunctions = fillArray(mongodbRandomWorld, 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) {
-    mysqlRandomWorld(function (err, result) {
-      if (err) { throw err; }
-      addTfbHeaders(res, 'json');
-      res.end(JSON.stringify(result));
-    });
-  },
-
-  mysqlMultipleQueries: function (queries, req, res) {
-    var queryFunctions = fillArray(mysqlRandomWorld, queries);
-
-    async.parallel(queryFunctions, function (err, results) {
-      if (err) { throw err; }
-      addTfbHeaders(res, 'json');
-      res.end(JSON.stringify(results));
-    });
-  },
-
-  mysqlFortunes: function (req, res) {
-    mysqlGetAllFortunes(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
-      }));
-    })
-  },
-
-  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));
-  }
-
-};
+//
+// Handlers, one for each db config
+//
+var MongodbRawHandler = require('./handlers/mongodb-raw');
+var MySQLRawHandler = require('./handlers/mysql-raw');
+// Mongoose is a popular Node/MongoDB driver
+var MongooseHandler = require('./handlers/mongoose')
+// Sequelize is a popular Node/SQL driver
+var SequelizeHandler = require('./handlers/sequelize')
 
 if (cluster.isMaster) {
   // Fork workers.
@@ -454,27 +31,27 @@ if (cluster.isMaster) {
 
     // Basic routes, no db required
     if (route === '/json') {
-      return responses.jsonSerialization(req, res);
+      return h.responses.jsonSerialization(req, res);
     } else if (route === '/plaintext') {
-      return responses.plaintext(req, res);
+      return h.responses.plaintext(req, res);
 
     // No queries parameter required
     } else if (route === '/mongoose/db') {
-      return responses.mongooseSingleQuery(req, res);
+      return MongooseHandler.SingleQuery(req, res);
     } else if (route === '/mongoose/fortunes') {
-      return responses.mongooseFortunes(req, res);
+      return MongooseHandler.Fortunes(req, res);
     } else if (route === '/mongodb/db') {
-      return responses.mongodbSingleQuery(req, res);
+      return MongodbRawHandler.SingleQuery(req, res);
     } else if (route === '/mongodb/fortunes') {
-      return responses.mongodbFortunes(req, res);
+      return MongodbRawHandler.Fortunes(req, res);
     } else if (route === '/sequelize/db') {
-      return responses.sequelizeSingleQuery(req, res);
+      return SequelizeHandler.SingleQuery(req, res);
     } else if (route === '/sequelize/fortunes') {
-      return responses.sequelizeFortunes(req, res);
+      return SequelizeHandler.Fortunes(req, res);
     } else if (route === '/mysql/db') {
-      return responses.mysqlSingleQuery(req, res);
+      return MySQLRawHandler.SingleQuery(req, res);
     } else if (route === '/mysql/fortunes') {
-      return responses.mysqlFortunes(req, res);
+      return MySQLRawHandler.Fortunes(req, res);
     }
 
     else {
@@ -482,21 +59,21 @@ if (cluster.isMaster) {
       queries = Math.min(Math.max(queries, 1), 500);
 
       if (route === '/mongoose/queries') {
-        return responses.mongooseMultipleQueries(queries, req, res);
+        return MongooseHandler.MultipleQueries(queries, req, res);
       } else if (route === '/mongoose/updates') {
-        return responses.mongooseUpdates(queries, req, res);
+        return MongooseHandler.Updates(queries, req, res);
       } else if (route === '/mongodb/queries') {
-        return responses.mongodbMultipleQueries(queries, req, res);
+        return MongodbRawHandler.MultipleQueries(queries, req, res);
       } else if (route === '/mongodb/updates') {
-        return responses.mongodbUpdates(queries, req, res);
+        return MongodbRawHandler.Updates(queries, req, res);
       } else if (route === '/sequelize/queries') {
-        return responses.sequelizeMultipleQueries(queries, req, res);
+        return SequelizeHandler.MultipleQueries(queries, req, res);
       } else if (route === '/sequelize/updates') {
-        return responses.sequelizeUpdates(queries, req, res);
+        return SequelizeHandler.Updates(queries, req, res);
       } else if (route === '/mysql/queries') {
-        return responses.mysqlMultipleQueries(queries, req, res);
+        return MySQLRawHandler.MultipleQueries(queries, req, res);
       } else if (route === '/mysql/updates') {
-        return responses.mysqlUpdates(queries, req, res);
+        return MySQLRawHandler.Updates(queries, req, res);
       } else {
         return responses.routeNotImplemented(req, res);
       }

frameworks/JavaScript/nodejs/helper.js

@@ -0,0 +1,82 @@
+var Handlebars = require('handlebars');
+
+var GREETING = "Hello, World!";
+var HELLO_OBJ = { message: GREETING };
+
+var self = module.exports = {
+
+  ADDITIONAL_FORTUNE: {
+    id: 0,
+    message: 'Additional fortune added at request time.'
+  },
+
+  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('')),
+
+  randomTfbNumber: function () {
+    return Math.floor(Math.random() * 10000) + 1;
+  },
+
+  fillArray: function(value, len) {
+    var arr = [];
+    for (var i = 0; i < len; i++) {
+      arr.push(value);
+    }
+    return arr;
+  },
+
+  addTfbHeaders: function (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);
+  },
+
+  responses: {
+
+    jsonSerialization: function (req, res) {
+      self.addTfbHeaders(res, 'json');
+      res.end(JSON.stringify(HELLO_OBJ));
+    },
+
+    plaintext: function (req, res) {
+      self.addTfbHeaders(res, 'plain');
+      res.end(GREETING);
+    },
+
+    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));
+    }
+
+  }
+
+};