cloudcms-server 0.9.301 → 3.2.278

package/.last_command

@@ -0,0 +1,7 @@
+{
+  "command": {
+    "group": "server",
+    "name": "start"
+  },
+  "arguments": {}
+}

package/LICENSE

@@ -1,6 +1,6 @@
 Cloud CMS Application Server Module
 
-Copyright 2019 Gitana Software, Inc.
+Copyright 2022 Gitana Software, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License"); 
 you may not use this file except in compliance with the License. 

package/README.md

@@ -13,7 +13,7 @@ This looks like:
 
 ````
 {
-    "setup": "single", // single, cluster, sticky-cluster
+    "setup": "single", // single, cluster, redis
     "name": "Cloud CMS Application Server",
     "socketFunctions": [],
     "routeFunctions": [],

package/broadcast/providers/redis.js

@@ -1,8 +1,7 @@
-var path = require("path");
+var redisClientFactory = require("../../clients/redis");
+var redisHelper = require("../../util/redis");
 
-var NRP = require('node-redis-pubsub');
-
-var logFactory = require("../../util/logger");
+var NRP = require("../../clients/nrp");
 
 /**
  * Redis broadcast provider.
@@ -12,55 +11,31 @@ var logFactory = require("../../util/logger");
 exports = module.exports = function(broadcastConfig)
 {
     var nrp = null;
-
-    var logger = logFactory("REDIS BROADCAST");
-    logger.setLevel("error");
-
-    // allow for global redis default
-    // allow for redis broadcast specific
-    // otherwise default to "error"
-    if (typeof(process.env.CLOUDCMS_REDIS_DEBUG_LEVEL) !== "undefined") {
-        logger.setLevel(("" + process.env.CLOUDCMS_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-    }
-    else if (typeof(process.env.CLOUDCMS_BROADCAST_REDIS_DEBUG_LEVEL) !== "undefined") {
-        logger.setLevel(("" + process.env.CLOUDCMS_BROADCAST_REDIS_DEBUG_LEVEL).toLowerCase(), true);
-    }
-
+    
+    var logger = redisHelper.redisLogger("REDIS_BROADCAST", "CLOUDCMS_BROADCAST_", "error")
+    
     var r = {};
 
     r.start = function(callback)
     {
-        var redisPort = broadcastConfig.port;
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_BROADCAST_REDIS_PORT;
-        }
-        if (typeof(redisPort) === "undefined" || !redisPort)
-        {
-            redisPort = process.env.CLOUDCMS_REDIS_PORT;
-        }
-
-        var redisEndpoint = broadcastConfig.endpoint;
-        if (typeof(redisEndpoint) === "undefined" || !redisEndpoint)
-        {
-            redisEndpoint = process.env.CLOUDCMS_BROADCAST_REDIS_ENDPOINT;
-        }
-        if (typeof(redisEndpoint) === "undefined" || !redisEndpoint)
-        {
-            redisEndpoint = process.env.CLOUDCMS_REDIS_ENDPOINT;
-        }
-
-        var nrpConfig = {
-            "port": redisPort,
-            "host": redisEndpoint,
-            "scope": "broadcast_cache"
-        };
-
-        logger.info("using config = " + nrpConfig);
-        
-        nrp = new NRP(nrpConfig);
-
-        callback();
+        redisClientFactory.create(broadcastConfig, function(err, client) {
+            
+            if (err) {
+                return callback(err);
+            }
+    
+            var nrpConfig = {
+                "client": client,
+                "scope": "broadcast_cache"
+            };
+    
+            //logger.info("using config = " + nrpConfig);
+    
+            nrp = new NRP(nrpConfig);
+            nrp.connect(function(err) {
+                callback(err);
+            });
+        });
     };
 
     r.publish = function(topic, message, callback)

package/clients/nrp.js

@@ -0,0 +1,117 @@
+// a revision of
+// https://raw.githubusercontent.com/louischatriot/node-redis-pubsub/master/lib/node-redis-pubsub.js
+// that works with Redis 6+
+
+"use strict";
+var redis = require('redis');
+
+/**
+ * Create a new NodeRedisPubsub instance that can subscribe to channels and publish messages
+ * @param {Object} options Options for the client creations:
+ *                 client - a connected Redis client
+ *                 scope - Optional, two NodeRedisPubsubs with different scopes will not share messages
+ */
+function NodeRedisPubsub(options)
+{
+    if (!(this instanceof NodeRedisPubsub)){ return new NodeRedisPubsub(options); }
+    
+    options || (options = {});
+    
+    this.emitter = options.client.duplicate();
+    this.emitter.setMaxListeners(0);
+    this.receiver = options.client.duplicate();
+    this.receiver.setMaxListeners(0);
+    
+    this.prefix = options.scope ? options.scope + ':' : '';
+}
+
+NodeRedisPubsub.prototype.connect = function(callback)
+{
+    var self = this;
+    
+    (async function() {
+        await self.emitter.connect();
+        await self.receiver.connect();
+        callback();
+    })();
+};
+
+/**
+ * Subscribe to a channel
+ * @param {String} channel The channel to subscribe to, can be a pattern e.g. 'user.*'
+ * @param {Function} handler Function to call with the received message.
+ * @param {Function} cb Optional callback to call once the handler is registered.
+ */
+NodeRedisPubsub.prototype.on = NodeRedisPubsub.prototype.subscribe = function(channel, handler, callback)
+{
+    if (!callback)
+    {
+        callback = function(){};
+    }
+    
+    var self = this;
+    
+    if (channel === "error")
+    {
+        self.errorHandler = handler;
+        self.emitter.on("error", handler);
+        self.receiver.on("error", handler);
+        return callback();
+    }
+    
+    var listener = function(self, handler)
+    {
+        return function(message, channel) {
+    
+            var jsonmsg = message;
+            try{
+                jsonmsg = JSON.parse(message);
+            } catch (ex){
+                if(typeof self.errorHandler === 'function'){
+                    return self.errorHandler("Invalid JSON received! Channel: " + self.prefix + channel + " Message: " + message);
+                }
+            }
+            return handler(jsonmsg, channel);
+        }
+    }(self, handler);
+    
+    (async function() {
+        await self.receiver.pSubscribe(self.prefix + channel, listener);
+    })();
+    
+    callback();
+};
+
+/**
+ * Emit an event
+ * @param {String} channel Channel on which to emit the message
+ * @param {Object} message
+ */
+NodeRedisPubsub.prototype.emit = NodeRedisPubsub.prototype.publish = function (channel, message)
+{
+    var self = this;
+    
+    (async function() {
+        return await self.emitter.publish(self.prefix + channel, JSON.stringify(message));
+    })();
+};
+
+/**
+ * Safely close the redis connections 'soon'
+ */
+NodeRedisPubsub.prototype.quit = function()
+{
+    this.emitter.quit();
+    this.receiver.quit();
+};
+
+/**
+ * Dangerously close the redis connections immediately
+ */
+NodeRedisPubsub.prototype.end = function()
+{
+    this.emitter.end(true);
+    this.receiver.end(true);
+};
+
+module.exports = NodeRedisPubsub;

package/clients/redis.js

@@ -0,0 +1,64 @@
+//var redis = require("redis");
+var redisHelper = require("../util/redis");
+
+var clients = {};
+
+/**
+ * Redis client factory.
+ *
+ * @type {*}
+ */
+exports = module.exports = {};
+
+var create = exports.create = function(config, baseOptions, callback)
+{
+    if (typeof(config) === "function") {
+        callback = config;
+        config = {};
+        baseOptions = {};
+    }
+    
+    if (typeof(baseOptions) === "function") {
+        callback = baseOptions;
+        baseOptions = {};
+    }
+    
+    if (!config) {
+        config = {};
+    }
+    
+    if (!baseOptions) {
+        baseOptions = {};
+    }
+    
+    var redisOptions = redisHelper.redisOptions(config);
+    if (baseOptions) {
+        for (var k in baseOptions) {
+            redisOptions[k] = baseOptions[k];
+        }
+    }
+    
+    var url = redisOptions.url;
+    
+    // cached client?
+    var client = clients[url];
+    if (client) {
+        return callback(null, client);
+    }
+    
+    // connect
+    (async function() {
+        await redisHelper.createAndConnect(redisOptions, function(err, client) {
+            
+            if (err) {
+                return callback(err);
+            }
+            
+            // cache it
+            clients[url] = client;
+            
+            // return
+            return callback(null, client);
+        });
+    })();
+};

package/framework/controllers.js

@@ -163,10 +163,10 @@ var handleInvalidate = function(req, res)
     // new timestamp
     process.env.CLOUDCMS_APPSERVER_TIMESTAMP = new Date().getTime();
 
-    // update all socket clients
-    process.IO.sockets.emit("timestamp", {
-        "timestamp": process.env.CLOUDCMS_APPSERVER_TIMESTAMP
-    });
+    // // update all socket clients
+    // process.IO.sockets.emit("timestamp", {
+    //     "timestamp": process.env.CLOUDCMS_APPSERVER_TIMESTAMP
+    // });
 
     console.log("Server timestamp regenerated");
 

package/index.js

@@ -34,7 +34,7 @@ process.logInfo = process.log = function(text, level)
 var Gitana = require("gitana");
 
 // default http timeout
-process.defaultHttpTimeoutMs = 120000; // 2 minutes
+process.defaultHttpTimeoutMs = 60000;
 
 if (process.env.DEFAULT_HTTP_TIMEOUT_MS)
 {
@@ -54,20 +54,18 @@ var HttpsKeepAliveAgent = require('agentkeepalive').HttpsAgent;
 http.globalAgent = new HttpKeepAliveAgent({
     keepAlive: true,
     keepAliveMsecs: 1000,
-    keepAliveTimeout: 30000,
+    maxSockets: 16000,
+    maxFreeSockets: 256,
     timeout: process.defaultHttpTimeoutMs,
-    maxSockets: 200,
-    maxFreeSockets: 40,
-    rejectUnauthorized: false
+    freeSocketTimeout: 30000
 });
 https.globalAgent = new HttpsKeepAliveAgent({
     keepAlive: true,
     keepAliveMsecs: 1000,
-    keepAliveTimeout: 30000,
+    maxSockets: 16000,
+    maxFreeSockets: 256,
     timeout: process.defaultHttpTimeoutMs,
-    maxSockets: 200,
-    maxFreeSockets: 40,
-    rejectUnauthorized: false
+    freeSocketTimeout: 30000
 });
 
 // disable for now
@@ -138,6 +136,7 @@ exports = module.exports = function()
     // not already specified
     var defaultGitanaProxyScheme = "https";
     var defaultGitanaProxyHost = "api.cloudcms.com";
+    var defaultGitanaProxyPath = "";
     var defaultGitanaProxyPort = 443;
 
     var gitanaJsonPath = path.join(process.env.CLOUDCMS_APPSERVER_BASE_PATH, "gitana.json");
@@ -149,6 +148,7 @@ exports = module.exports = function()
             var parsedUrl = url.parse(gitanaJson.baseURL);
 
             defaultGitanaProxyHost = parsedUrl.hostname;
+            defaultGitanaProxyPath = parsedUrl.path;
             defaultGitanaProxyScheme = parsedUrl.protocol.substring(0, parsedUrl.protocol.length - 1); // remove the :
 
             if (parsedUrl.port)
@@ -173,13 +173,16 @@ exports = module.exports = function()
     if (!process.env.GITANA_PROXY_HOST) {
         process.env.GITANA_PROXY_HOST = defaultGitanaProxyHost;
     }
+    if (!process.env.GITANA_PROXY_PATH) {
+        process.env.GITANA_PROXY_PATH = defaultGitanaProxyPath;
+    }
     if (!process.env.GITANA_PROXY_PORT) {
         process.env.GITANA_PROXY_PORT = defaultGitanaProxyPort;
     }
 
     if (cluster.isMaster)
     {
-        process.log("Gitana Proxy pointed to: " + util.asURL(process.env.GITANA_PROXY_SCHEME, process.env.GITANA_PROXY_HOST, process.env.GITANA_PROXY_PORT));
+        process.log("Gitana Proxy pointed to: " + util.asURL(process.env.GITANA_PROXY_SCHEME, process.env.GITANA_PROXY_HOST, process.env.GITANA_PROXY_PORT, process.env.GITANA_PROXY_PATH));
     }
 
     // all web modules are included by default

package/insight/insight.js

@@ -131,7 +131,7 @@ var doSend = function(callback)
     }
 
     // url over to cloud cms
-    var URL = util.asURL(process.env.GITANA_PROXY_SCHEME, process.env.GITANA_PROXY_HOST, process.env.GITANA_PROXY_PORT) + "/warehouses/" + warehouseId + "/interactions/_create";
+    var URL = util.asURL(process.env.GITANA_PROXY_SCHEME, process.env.GITANA_PROXY_HOST, process.env.GITANA_PROXY_PORT, process.env.GITANA_PROXY_PATH) + "/warehouses/" + warehouseId + "/interactions/_create";
     var requestConfig = {
         "url": URL,
         "qs": {},

package/launchpad/index.js

@@ -1,17 +1,180 @@
-module.exports = function(options)
+const cluster = require("cluster");
+
+// Handle uncaught exceptions...
+process.on('uncaughtException', function(err, source) {
+    // if (err === "read ECONNRESET")
+    // {
+    //     // skip
+    // }
+    // else
+    // {
+        console.log(`Launchpad - process received event 'uncaughtException': ${err}, source: ${source}`);
+        console.log(err.stack);
+    // }
+});
+
+module.exports = function(type, config, options)
 {
-    // allow for override
-    if (process.env.CLOUDCMS_LAUNCHPAD_SETUP) {
-        options.setup = process.env.CLOUDCMS_LAUNCHPAD_SETUP;
+    if (!type) {
+        type = process.env.CLOUDCMS_LAUNCHPAD_SETUP;
     }
-
-    // default to single mode
-    if (!options.setup) {
-        options.setup = "single";
+    if (!type) {
+        type = "single";
+    }
+    
+    process.env.CLOUDCMS_LAUNCHPAD_SETUP = type
+    
+    var launcherFactory = require("./launchers/" + type);
+    if (!launcherFactory)
+    {
+        throw new Error("Cannot find launcher factory: " + type);
+    }
+    
+    var launcher = launcherFactory(config);
+    
+    var reportFn = options.report;
+    if (!reportFn) {
+        options.report = reportFn = function () {};
+    }
+    
+    var completionFn = options.complete;
+    if (!completionFn) {
+        options.complete = completionFn = function(err) {
+            throw new Error(err);
+        };
+    }
+    
+    var fork = true;
+    if (type === "single") {
+        fork = false;
     }
+    
+    if (!fork)
+    {
+        return launchWorker(launcher, config, options, function(err, app, httpServer) {
+            
+            if (err) {
+                return completionFn(config, err);
+            }
+    
+            var httpServerPort = -1;
+            // if (app) {
+            //     httpServerPort = app.get("port");
+            // }
+            if (httpServerPort === -1) {
+                httpServerPort = process.env.PORT;
+            }
+            if (httpServerPort === -1) {
+                httpServerPort = 3000;
+            }
+    
+            httpServer.listen(httpServerPort);
+    
+            reportFn(config);
+            completionFn(config);
+        });
+    }
+    else
+    {
+        if (cluster.isMaster)
+        {
+            return launchMaster(launcher, config, options, function(err, workers) {
+    
+                if (err) {
+                    return completionFn(config, err);
+                }
+    
+                //reportFn(config);
+                completionFn(config);
+            });
+        }
+        else
+        {
+            return launchWorker(launcher, config, options, function(err) {
+                completionFn(config, err);
+            });
+        }
+    }
+};
+
+var launchMaster = function(launcher, config, options, done)
+{
+    var createHttpServer = options.createHttpServer;
+    
+    createHttpServer(null, function(err, httpServer) {
+        
+        if (err) {
+            return done(err);
+        }
+    
+        launcher.startCluster(httpServer, function(err) {
+    
+            if (err) {
+                return done(err);
+            }
+    
+            var httpServerPort = -1;
+            // if (app) {
+            //     httpServerPort = app.get("port");
+            // }
+            if (httpServerPort === -1) {
+                httpServerPort = process.env.PORT;
+            }
+            if (httpServerPort === -1) {
+                httpServerPort = 3000;
+            }
+    
+            httpServer.listen(httpServerPort);
+    
+            launcher.afterStartCluster(httpServer, function(err, workers) {
+                done(err, workers);
+            });
+        });
+    });
+};
 
-    process.env.CLOUDCMS_LAUNCHPAD_SETUP = options.setup;
+var launchWorker = function(launcher, config, options, done)
+{
+    var startServer = options.startServer;
+    
+    var configureServer = options.configureServer;
+    if (!configureServer) {
+        options.configureServer = configureServer = function(config, app, httpServer, done) {
+            done();
+        }
+    }
+    
+    startServer(config, function(err, app, httpServer) {
+        
+        if (err) {
+            return done(err);
+        }
+        
+        launcher.afterStartServer(app, httpServer, function(err) {
+            
+            if (err) {
+                return done(err);
+            }
+    
+            configureServer(config, app, httpServer, function(err) {
+                
+                if (err) {
+                    return done(err);
+                }
+                
+                // if we are on a worker process, then inform the master that we completed
+                if (process.send) {
+                    process.send("worker-startup");
+                }
+    
+                if (process.env["CLUSTER_REPORT"])
+                {
+                    var reportFn = options.report;
+                    reportFn(config);
+                }
 
-    var launch = require("./launchers/" + options.setup);
-    launch(options);
+                done(null, app, httpServer);
+            });
+        });
+    });
 };