roster-server/vendor/greenlock/greenlockrc.js

👾 RosterServer - A domain host router to host multiple HTTPS.

'use strict';

var log = require('lemonlog')('greenlock-rc-file');
var fs = require('fs');
var path = require('path');

function saveFile(rcpath, data, enc) {
    // because this may have a database url or some such
    fs.writeFileSync(rcpath, data, enc);
    return fs.chmodSync(rcpath, parseInt('0600', 8));
}

var GRC = (module.exports = function(pkgpath, manager, rc) {
    // TODO when run from package
    // Run from the package root (assumed) or exit
    var pkgdir = path.dirname(pkgpath);

    try {
        require(pkgpath);
    } catch (e) {
        log.error('Run greenlock from package root (directory containing package.json)');
        process.exit(1);
    }

    try {
        return module.exports._defaults(pkgdir, manager, rc);
    } catch (e) {
        if ('package.json' === e.context) {
            log.error(e.desc);
        } else {
            log.error(e.message);
        }
        process.exit(1);
    }
});

// Figure out what to do between what's hard-coded,
// what's in the config file, and what's left unset
module.exports.resolve = function(gconf) {
    var rc = GRC.read(gconf.packageRoot);
    if (gconf.configFile) {
        rc = { configFile: gconf.configFile };
    }

    var manager;
    var updates;

    if (rc.manager) {
        if (gconf.manager && rc.manager !== gconf.manager) {
            log.warn('Using manager from .greenlockrc (%s) instead of hard-coded %s', rc.manager, gconf.manager);
        }
        gconf.manager = rc.manager;
    } else if (gconf.manager) {
        manager = gconf.manager;
    }

    if (rc.configFile) {
        if (gconf.configFile && rc.configFile !== gconf.configFile) {
            log.warn('Using configFile from .greenlockrc instead of hard-coded value');
        }
        gconf.configFile = rc.configFile;
    } else if (gconf.manager) {
        updates = { configFile: gconf.configFile };
    }

    return GRC._defaults(gconf.packageRoot, manager, rc);
};

module.exports._defaults = function(pkgdir, manager, rc) {
    var rcpath = path.join(pkgdir, '.greenlockrc');
    var _rc;
    var created = false;

    if (manager) {
        if ('.' === manager[0]) {
            manager = path.resolve(pkgdir, manager);
        }
        try {
            require(manager);
        } catch (e) {
            log.error('Could not load manager %s from %s', manager, pkgdir);
            throw e;
        }
    }

    var stuff = module.exports._read(pkgdir);
    _rc = stuff.rc;
    created = stuff.created;

    var changed;
    if (manager) {
        if (!_rc.manager) {
            _rc.manager = manager;
        }
        if (_rc.manager !== manager) {
            var older = _rc.manager;
            var newer = manager;
            if ('/' === (older || '')[0]) older = path.relative(pkgdir, older);
            if ('/' === (newer || '')[0]) newer = path.relative(pkgdir, newer);
            log.info('Switching manager: %s -> %s', older, newer);
            changed = true;
        }
    }

    if (rc) {
        changed = true;
        Object.keys(rc).forEach(function(k) {
            _rc[k] = rc[k];
        });
    }

    if (['@greenlock/manager', 'greenlock-manager-fs'].includes(_rc.manager)) {
        if (!_rc.configFile) {
            changed = true;
            _rc.configFile = path.join(pkgdir, 'greenlock.json');
        }
    }

    if (!changed) {
        return _rc;
    }

    var data = JSON.stringify(_rc, null, 2);
    if (created) log.info('Created %s', rcpath);
    saveFile(rcpath, data, 'utf8');
    return _rc;
};

module.exports.read = function(pkgdir) {
    return module.exports._read(pkgdir).rc;
};

module.exports._read = function(pkgdir) {
    var created;
    var rcpath = path.join(pkgdir, '.greenlockrc');
    var _data;
    try {
        _data = fs.readFileSync(rcpath, 'utf8');
    } catch (err) {
        if ('ENOENT' !== err.code) {
            throw err;
        }
        try {
            require(path.resolve(path.join(pkgdir, './package.json')));
        } catch (e) {
            e.context = 'package.json';
            e.desc =
                'run `greenlock` from the same directory as `package.json`, or specify `packageRoot` of `.greenlockrc`';
            throw e;
        }
        log.info('Creating %s', rcpath);
        created = true;
        _data = '{}';
        saveFile(rcpath, _data, 'utf8');
    }

    var rc;
    try {
        rc = JSON.parse(_data);
    } catch (e) {
        log.error("Invalid JSON in %s (delete and retry?)", rcpath, e.message);
        process.exit(1);
    }

    return {
        created: created,
        rc: rc
    };
};