Gecko [ re-designstudio.net ]

Name	Size	Permission	Date
RackRunner.rb	4.49 KB	-r-xr-xr-x	2026-08-15 11:10
RailsRunner.rb	4.6 KB	-r-xr-xr-x	2026-08-15 11:10
RailsRunner.rb.2.3	1.07 KB	-r-xr-xr-x	2026-08-15 11:10
lsnode.js	15.62 KB	-r-xr-xr-x	2026-08-15 11:10
lsnodesm.js	15.77 KB	-r-xr-xr-x	2026-08-15 11:10
lsperld.fpl	3.26 KB	-r-xr-xr-x	2017-11-22 05:14
lsphp	4.6 MB	-r-xr-xr-x	2017-11-22 05:14
lsphp4	4.6 MB	-r-xr-xr-x	2017-11-22 05:14
lsphp5	5.9 MB	-rwxr-xr-x	2026-07-22 09:25
lsphp7	5.93 MB	-rwxr-xr-x	2026-07-22 09:38
lswsgi_wrapper	387 B	-r-xr-xr-x	2026-08-15 11:10

Rename

/*
 * Copyright 2002-2018 Lite Speed Technologies Inc, All Rights Reserved.
 * LITE SPEED PROPRIETARY/CONFIDENTIAL.
 */

var EventEmitter = require('events').EventEmitter;
var os = require('os');
var fs = require('fs');
var http = require('http');
var util = require('util');
var net = require('net');

var socketObject = process.env.LSNODE_BIND_SOCKET
    ? { path: process.env.LSNODE_SOCKET }
    : { fd: 0 };

/*
 * Child process supervision.
 *
 * An application may create its own child processes.  When this process goes
 * away those children have to go away as well, otherwise they are re-parented
 * to init and stay around forever, holding memory, sockets and, on a restart,
 * possibly the listening socket of the application.
 *
 *   - every child created through child_process is tracked and signaled when
 *     this process terminates in a way it can observe: normal exit, exit()
 *     call, uncaught exception, SIGTERM/SIGINT/SIGHUP/SIGQUIT.
 *   - children created with fork() additionally load this file through
 *     --require.  That copy only installs a watcher which terminates the child
 *     as soon as its parent is gone.  It is the only thing that covers a
 *     SIGKILL of the parent, where no handler of ours can run, and it applies
 *     to grandchildren as well because the child tracks its own children too.
 *
 * Children started with spawn()/exec() cannot be given that watcher - they are
 * not necessarily node processes - so for them only the observable paths above
 * are handled.
 *
 * Set LSNODE_KEEP_CHILDREN=1 to disable all of this.
 */
var PPID_ENV = 'LSNODE_GUARD_PPID';
var PARENT_CHECK_INTERVAL = 1000;
var FORCE_KILL_DELAY = 3000;
var children = [];
var terminating = false;

if (require.main !== module) {
    // Loaded with --require into a child process, act as the watchdog only.
    // Read the parent pid first, supervising resets PPID_ENV to our own pid.
    var guardPpid = parseInt(process.env[PPID_ENV], 10);
    superviseChildProcesses();
    watchParent(guardPpid);
} else {
    module.isApplicationLoader = true;
    global.LsNode = new EventEmitter();
    superviseChildProcesses();
    startApplication();
}

function isKeepChildren() {
    var keep = process.env.LSNODE_KEEP_CHILDREN;
    return keep !== undefined && keep !== '' && keep !== '0';
}

function isDetached(args, from) {
    var idx = findOptions(args, from);
    return idx >= 0 && args[idx].detached === true;
}

function superviseChildProcesses() {
    if (isKeepChildren()) {
        return;
    }

var cp = require('child_process');
    var origSpawn = cp.spawn;
    var origFork = cp.fork;
    var origExec = cp.exec;
    var origExecFile = cp.execFile;

// Inherited by every child unless it is given an environment of its own.
    process.env[PPID_ENV] = String(process.pid);

cp.spawn = function(command) {
        return trackChild(origSpawn.apply(this, arguments),
                          isDetached(arguments, 1));
    };

cp.execFile = function(file) {
        return trackChild(origExecFile.apply(this, arguments),
                          isDetached(arguments, 1));
    };

// Some Node versions implement exec() through the exported execFile(),
    // while others call an internal function.  trackChild() de-duplicates the
    // former case.
    cp.exec = function(command) {
        return trackChild(origExec.apply(this, arguments),
                          isDetached(arguments, 1));
    };

// execSync()/spawnSync() have been reaped by the time they return, so
    // fork() is the last one left.  Normalize its two valid signatures before
    // adding the preloader: fork(module[, options]) and
    // fork(module[, args][, options]).
    cp.fork = function(modulePath, args, options) {
        if (args === undefined || args === null) {
            args = [];
        } else if (typeof args === 'object' && !Array.isArray(args)) {
            options = args;
            args = [];
        }
        if (options === undefined || options === null) {
            options = {};
        }
        if (typeof options !== 'object' || Array.isArray(options)) {
            // Preserve Node's normal argument validation and error.
            return origFork.call(this, modulePath, args, options);
        }
        var opts = Object.assign({}, options);

process.on('exit', function() {
        killChildren('SIGTERM');
    });

function startApplication() {
    var appRoot = process.env.LSNODE_ROOT || process.cwd();
    var startupFile = process.env.LSNODE_STARTUP_FILE || 'app.js';
    LsNode.listenDone = false;

if (process.env.LSNODE_ROOT != undefined) {
        try {
            process.chdir(process.env.LSNODE_ROOT);
        } catch (err) {
            console.error("Error setting directory to: " + 
                          process.env.LSNODE_ROOT + ": " + err);
        }
    }
    if (!startupFile.startsWith('/')) {
        if (!appRoot.endsWith('/')) {
            appRoot = appRoot + '/';
        }
        startupFile = appRoot + startupFile;
    }

process.title = 'lsnode:' + appRoot;

function lsnode_address() {
    return process.env.LSNODE_SOCKET;
}

var callback;
    if (arguments.length > 1 && typeof(arguments[arguments.length - 1]) == 'function') {
        callback = arguments[arguments.length - 1];
    }
    server.once('error', onListenError);
    var lsBindMask;
    var lsBindPath = process.env.LSNODE_BIND_SOCKET
        ? process.env.LSNODE_SOCKET : null;
    if (lsBindPath) {
        // The application owns and binds the unix socket; LiteSpeed connects to
        // it by path. Remove any stale socket from a previous run, and bind
        // under a umask that makes it group-writable (0660) so the web server
        // worker -- which shares the socket's group via the set-gid directory --
        // can connect.
        try { fs.unlinkSync(lsBindPath); } catch (e) {}
        lsBindMask = process.umask(0o117);
    }
    try {
        server.realListen(socketObject, function() {
            if (lsBindPath) {
                // bind() applied the mask above, this covers the socket being
                // created after it was restored, and is a no-op otherwise.
                try { fs.chmodSync(lsBindPath, 0o660); } catch (e) {}
                restoreBindMask();
            }
            server.removeListener('error', onListenError);
            if (callback) {
                server.once('listening', callback);
            }
            server.emit('listening');
        });
    } catch (err) {
        restoreBindMask();
        throw err;
    }
    // Binding a unix socket finishes inside listen(), so the mask has done its
    // job by the time it returns.  Restore it here rather than from the
    // callback above: node emits 'listening' to the application's own handlers
    // first, and those must not run under our mask.
    restoreBindMask();
    return server;
}