ICE-6634 - Using Ice in background worker.

1 files changed, 240 insertions, 154 deletions

diff --git a/js/bin/HttpServer.js b/js/bin/HttpServer.js
index 7dd5a2241ce..39a5e8c7e05 100644
--- a/js/bin/HttpServer.js
+++ b/js/bin/HttpServer.js
@@ -13,18 +13,7 @@ var http      = require("http");
 var https     = require("https");
 var path      = require("path");
 var url       = require("url");
-
-function isdir(p)
-{
-    try
-    {
-        return fs.statSync(path.join(p)).isDirectory();
-    }
-    catch(e)
-    {
-    }
-    return false;
-}
+var hogan     = require("hogan.js");
 
 function Init()
 {
@@ -37,11 +26,24 @@ function Init()
         json: "application/json",
     };
 
+    var TestData =
+        {
+            languages: [{value: "cpp", name: "C++"}, {value: "java", name: "Java"}]
+        };
+    if(process.platform == "win32")
+    {
+        serverLanguages.languages.push({value: "csharp", name: "C#"});
+    }
+
     var libraries = ["/lib/Ice.js", "/lib/Ice.min.js",
                     "/lib/Glacier2.js", "/lib/Glacier2.min.js",
                     "/lib/IceStorm.js", "/lib/IceStorm.min.js",
                     "/lib/IceGrid.js", "/lib/IceGrid.min.js",];
 
+    TestData.TestCases = fs.readFileSync(path.join(__dirname, "..", "test", "Common", "TestCases.json"), "utf8");
+    var TestCases = JSON.parse(TestData.TestCases);
+    TestData.tests = Object.keys(TestCases);
+    var template = hogan.compile(fs.readFileSync(path.join(__dirname, "..", "test", "Common", "index.html"), "utf8"));
     var libraryMaps = libraries.map(
         function(f)
         {
@@ -50,168 +52,250 @@ function Init()
 
     var HttpServer = function(host, ports)
     {
-        this._host = host;
-        this._ports = ports;
         this._basePath = path.resolve(path.join(__dirname, ".."));
     };
 
     HttpServer.prototype.processRequest = function(req, res)
     {
-        var iceLib = libraries.indexOf(req.url.pathname) !== -1;
-        var iceLibMap = libraryMaps.indexOf(req.url.pathname) !== -1;
-
-        var basePath = (process.env.USE_BIN_DIST == "yes" && (iceLib || iceLibMap)) ?
-            path.resolve(path.join(require.resolve("ice"), "..", "..")) : this._basePath;
-
-        var filePath = path.resolve(path.join(basePath, req.url.pathname));
-
-        //
-        // If OPTIMIZE is set resolve Ice libraries to the corresponding minified
-        // versions.
-        //
-        if(process.env.OPTIMIZE == "yes")
+        var match = req.url.pathname.match("^\/test/(.*)/index\.html");
+        if(match)
         {
-            if(iceLib && filePath.substr(-7) !== ".min.js")
+            // That is a test case
+            var testCase = TestCases[match[1]];
+            if(testCase === undefined)
             {
-                filePath = filePath.replace(".js", ".min.js");
+                res.writeHead(404);
+                res.end("404 Page Not Found");
+                console.log("HTTP/404 (Page Not Found)" + req.method + " " + req.url.pathname);
             }
-            else if(iceLibMap && filePath.substr(-11) !== ".min.js.map")
+            else
             {
-                filePath = filePath.replace(".js.map", ".min.js.map");
-            }
-        }
-
-        var ext = path.extname(filePath).slice(1);
+                TestData.current = match[1];
+                if(req.url.query.next == "true")
+                {
+                    var testCase = TestData.tests[0];
+                    var language = req.url.query.language !== undefined ? req.url.query.language : "cpp";
+                    var protocol = req.url.protocol;
+                    var i = TestData.tests.indexOf(TestData.current);
+                    var worker = req.url.query.worker == "true";
 
-        //
-        // When the browser ask for a .js or .css file and it has support for gzip content
-        // check if a gzip version (.js.gz or .css.gz) of the file exists and use that instead.
-        //
-        if((ext == "js" || ext == "css" || ext == "map") && req.headers["accept-encoding"].indexOf("gzip") !== -1)
-        {
-            fs.stat(filePath + ".gz",
-                    function(err, stats)
+                    if(i < TestData.tests.length - 1)
                     {
-                        if(err || !stats.isFile())
-                        {
-                            fs.stat(filePath,
-                                    function(err, stats)
-                                    {
-                                        doRequest(err, stats, filePath);
-                                    });
-                        }
-                        else
-                        {
-                            doRequest(err, stats, filePath + ".gz");
-                        }
-                    });
-        }
-        else
-        {
-            fs.stat(filePath,
-                        function(err, stats)
+                        testCase = TestData.tests[i + 1];
+                    }
+                    else if(!worker)
+                    {
+                        worker = true;
+                    }
+                    else if(protocol == "http")
+                    {
+                        protocol = "https";
+                    }
+                    else
+                    {
+                        var languages = TestData.languages.map(function(o) { return o.value; });
+                        var j = languages.indexOf(language);
+                        language = languages[j == languages.length - 1 ? 0 : j + 1];
+                        worker = false;
+                        protocol = "http";
+                    }
+
+                    var location = url.format(
                         {
-                            doRequest(err, stats, filePath);
+                            protocol: protocol,
+                            hostname: req.headers.host.split(":")[0],
+                            port: (protocol == "http" ? 8080 : 9090),
+                            pathname: ("/test/" + testCase + "/index.html"),
+                            query:{loop: "true", language: language, worker: worker}
                         });
-        }
 
-        var doRequest = function(err, stats, filePath)
-        {
-            if(err)
-            {
-                if(err.code === "ENOENT")
-                {
-                    res.writeHead(404);
-                    res.end("404 Page Not Found");
-                    console.log("HTTP/404 (Page Not Found)" + req.method + " " + req.url.pathname + " -> " + filePath);
+                    res.writeHead(302, {"Location": location});
+                    res.end();
+                    console.log("HTTP/302 (Redierct) -> " + location);
                 }
                 else
                 {
-                    res.writeHead(500);
-                    res.end("500 Internal Server Error");
-                    console.log("HTTP/500 (Internal Server Error) " + req.method + " " + req.url.pathname + " -> " +
-                                filePath);
+                    if(req.url.query.worker != "true")
+                    {
+                        TestData.scripts =
+                            [
+                                "/lib/Ice.js",
+                                "/test/Common/TestRunner.js",
+                                "/test/Common/TestSuite.js",
+                                "/test/Common/Controller.js"
+                            ].concat(testCase.files);
+                    }
+                    else
+                    {
+                        TestData.scripts =
+                            [
+                                "/test/Common/TestSuite.js"
+                            ];
+                    }
+                    res.writeHead(200, {"Content-Type": "text/html"});
+                    res.end(template.render(TestData));
+                    console.log("HTTP/200 (Ok)" + req.method + " " + req.url.pathname);
                 }
             }
-            else
+        }
+        else
+        {
+            var iceLib = libraries.indexOf(req.url.pathname) !== -1;
+            var iceLibMap = libraryMaps.indexOf(req.url.pathname) !== -1;
+
+            var basePath = (process.env.USE_BIN_DIST == "yes" && (iceLib || iceLibMap)) ?
+                path.resolve(path.join(require.resolve("ice"), "..", "..")) : this._basePath;
+
+            var filePath = path.resolve(path.join(basePath, req.url.pathname));
+
+            //
+            // If OPTIMIZE is set resolve Ice libraries to the corresponding minified
+            // versions.
+            //
+            if(process.env.OPTIMIZE == "yes")
             {
-                if(req.url.pathname === '/')
+                if(iceLib && filePath.substr(-7) !== ".min.js")
                 {
-                    res.writeHead(302,
-                    {
-                        "Location": "test/Ice/acm/index.html"
-                    });
-                    res.end();
-                    console.log("HTTP/302 (Found) " + req.method + " " + req.url.pathname + " -> " +
-                                "test/Ice/acm/index.html");
+                    filePath = filePath.replace(".js", ".min.js");
                 }
-                else if(!stats.isFile())
+                else if(iceLibMap && filePath.substr(-11) !== ".min.js.map")
                 {
-                    res.writeHead(403);
-                    res.end("403 Forbiden");
-                    console.log("HTTP/403 (Forbiden) " + req.method + " " + req.url.pathname + " -> " + filePath);
+                    filePath = filePath.replace(".js.map", ".min.js.map");
                 }
-                else
-                {
-                    //
-                    // Create a md5 using the stats attributes
-                    // to be used as Etag header.
-                    //
-                    var hash = crypto.createHash("md5");
-                    hash.update(stats.ino.toString());
-                    hash.update(stats.mtime.toString());
-                    hash.update(stats.size.toString());
+            }
 
-                    var headers =
-                    {
-                        "Content-Type": MimeTypes[ext] || "text/plain",
-                        "Content-Length": stats.size,
-                        "Etag": hash.digest("hex")
-                    };
+            var ext = path.extname(filePath).slice(1);
 
-                    if(path.extname(filePath).slice(1) == "gz")
+            //
+            // When the browser ask for a .js or .css file and it has support for gzip content
+            // check if a gzip version (.js.gz or .css.gz) of the file exists and use that instead.
+            //
+            if((ext == "js" || ext == "css" || ext == "map") && req.headers["accept-encoding"].indexOf("gzip") !== -1)
+            {
+                fs.stat(filePath + ".gz",
+                        function(err, stats)
+                        {
+                            if(err || !stats.isFile())
+                            {
+                                fs.stat(filePath,
+                                        function(err, stats)
+                                        {
+                                            doRequest(err, stats, filePath);
+                                        });
+                            }
+                            else
+                            {
+                                doRequest(err, stats, filePath + ".gz");
+                            }
+                        });
+            }
+            else
+            {
+                fs.stat(filePath,
+                            function(err, stats)
+                            {
+                                doRequest(err, stats, filePath);
+                            });
+            }
+
+            var doRequest = function(err, stats, filePath)
+            {
+                if(err)
+                {
+                    if(err.code === "ENOENT")
                     {
-                        headers["Content-Encoding"] = "gzip";
+                        res.writeHead(404);
+                        res.end("404 Page Not Found");
+                        console.log("HTTP/404 (Page Not Found)" + req.method + " " + req.url.pathname + " -> " + filePath);
                     }
-
-                    //
-                    // Check for conditional request header if-none-match.
-                    //
-                    var modified = true;
-                    if(req.headers["if-none-match"] !== undefined)
+                    else
                     {
-                        modified = req.headers["if-none-match"].split(" ").every(
-                            function(element, index, array)
-                            {
-                                return element !== headers.Etag;
-                            });
+                        res.writeHead(500);
+                        res.end("500 Internal Server Error");
+                        console.log("HTTP/500 (Internal Server Error) " + req.method + " " + req.url.pathname + " -> " +
+                                    filePath);
                     }
-
-                    //
-                    // Not Modified
-                    //
-                    if(!modified)
+                }
+                else
+                {
+                    if(req.url.pathname === '/')
                     {
-                        res.writeHead(304, headers);
+                        res.writeHead(302,
+                        {
+                            "Location": "/test/Ice/acm/index.html"
+                        });
                         res.end();
-                        console.log("HTTP/304 (Not Modified) " + req.method + " " + req.url.pathname + " -> " + filePath);
+                        console.log("HTTP/302 (Found) " + req.method + " " + req.url.pathname + " -> " +
+                                    "/test/Ice/acm/index.html");
+                    }
+                    else if(!stats.isFile())
+                    {
+                        res.writeHead(403);
+                        res.end("403 Forbiden");
+                        console.log("HTTP/403 (Forbiden) " + req.method + " " + req.url.pathname + " -> " + filePath);
                     }
                     else
                     {
-                        res.writeHead(200, headers);
-                        if(req.method === "HEAD")
+                        //
+                        // Create a md5 using the stats attributes
+                        // to be used as Etag header.
+                        //
+                        var hash = crypto.createHash("md5");
+                        hash.update(stats.ino.toString());
+                        hash.update(stats.mtime.toString());
+                        hash.update(stats.size.toString());
+
+                        var headers =
+                        {
+                            "Content-Type": MimeTypes[ext] || "text/plain",
+                            "Content-Length": stats.size,
+                            "Etag": hash.digest("hex")
+                        };
+
+                        if(path.extname(filePath).slice(1) == "gz")
+                        {
+                            headers["Content-Encoding"] = "gzip";
+                        }
+
+                        //
+                        // Check for conditional request header if-none-match.
+                        //
+                        var modified = true;
+                        if(req.headers["if-none-match"] !== undefined)
                         {
+                            modified = req.headers["if-none-match"].split(" ").every(
+                                function(element, index, array)
+                                {
+                                    return element !== headers.Etag;
+                                });
+                        }
+
+                        //
+                        // Not Modified
+                        //
+                        if(!modified)
+                        {
+                            res.writeHead(304, headers);
                             res.end();
+                            console.log("HTTP/304 (Not Modified) " + req.method + " " + req.url.pathname + " -> " + filePath);
                         }
                         else
                         {
-                            fs.createReadStream(filePath, { "bufferSize": 4 * 1024 }).pipe(res);
+                            res.writeHead(200, headers);
+                            if(req.method === "HEAD")
+                            {
+                                res.end();
+                            }
+                            else
+                            {
+                                fs.createReadStream(filePath, { "bufferSize": 4 * 1024 }).pipe(res);
+                            }
+                            console.log("HTTP/200 (Ok) " + req.method + " " + req.url.pathname + " -> " + filePath);
                         }
-                        console.log("HTTP/200 (Ok) " + req.method + " " + req.url.pathname + " -> " + filePath);
                     }
                 }
-            }
-        };
+            };
+        }
     };
 
     HttpServer.prototype.start = function()
@@ -223,34 +307,36 @@ function Init()
         });
 
         var self = this;
-        [httpServer, httpsServer].forEach(function(server)
-                        {
-                            server.on("request", function(req, res)
-                                    {
-                                            //
-                                            // Dummy data callback required so request end event is emitted.
-                                            //
-                                            var dataCB = function(data)
-                                            {
-                                            };
-
-                                            var endCB = function()
-                                            {
-                                                req.url = url.parse(req.url);
-                                                self.processRequest(req, res);
-                                            };
 
-                                            req.on("data", dataCB);
-                                            req.on("end", endCB);
-                                    });
-                        });
+        function createServerHandler(server, port, host)
+        {
+            server.on("request",
+                      function(req, res)
+                      {
+                          //
+                          // Dummy data callback required so request end event is emitted.
+                          //
+                          var dataCB = function(data)
+                          {
+                          };
+                          var endCB = function()
+                          {
+                              req.url = url.parse(req.url, true);
+                              req.url.protocol = port == 8080 ? "http" : "https";
+                              self.processRequest(req, res);
+                          };
+                          req.on("data", dataCB);
+                          req.on("end", endCB);
+                      });
+            server.listen(port, host);
+        }
 
-        httpServer.listen(8080, this._host);
-        httpsServer.listen(9090, this._host);
+        createServerHandler(httpServer, 8080, "0.0.0.0");
+        createServerHandler(httpsServer, 9090, "0.0.0.0");
         console.log("listening on ports 8080 (http) and 9090 (https)...");
     };
 
-    new HttpServer("0.0.0.0", [8080, 9090]).start();
+    new HttpServer().start();
 }
 
 module.exports = Init;