app.portBindings and newManifest.tcpPorts may be null

src/settings.js

@@ -0,0 +1,199 @@
+/* jslint node:true */
+
+'use strict';
+
+exports = module.exports = {
+    SettingsError: SettingsError,
+
+    getAutoupdatePattern: getAutoupdatePattern,
+    setAutoupdatePattern: setAutoupdatePattern,
+
+    getTimeZone: getTimeZone,
+    setTimeZone: setTimeZone,
+
+    getCloudronName: getCloudronName,
+    setCloudronName: setCloudronName,
+
+    getCloudronAvatar: getCloudronAvatar,
+    setCloudronAvatar: setCloudronAvatar,
+
+    getDefaultSync: getDefaultSync,
+    getAll: getAll,
+
+    AUTOUPDATE_PATTERN_KEY: 'autoupdate_pattern',
+    TIME_ZONE_KEY: 'time_zone',
+    CLOUDRON_NAME_KEY: 'cloudron_name',
+
+    events: new (require('events').EventEmitter)()
+};
+
+var assert = require('assert'),
+    config = require('./config.js'),
+    CronJob = require('cron').CronJob,
+    DatabaseError = require('./databaseerror.js'),
+    paths = require('./paths.js'),
+    safe = require('safetydance'),
+    settingsdb = require('./settingsdb.js'),
+    util = require('util'),
+    _ = require('underscore');
+
+var gDefaults = (function () {
+    var tz = safe.fs.readFileSync('/etc/timezone', 'utf8');
+    tz = tz ? tz.trim() : 'America/Los_Angeles';
+
+    var result = { };
+    result[exports.AUTOUPDATE_PATTERN_KEY] = '00 00 1,3,5,23 * * *';
+    result[exports.TIME_ZONE_KEY] = tz;
+    result[exports.CLOUDRON_NAME_KEY] = 'Cloudron';
+
+    return result;
+})();
+
+if (config.TEST) {
+    // avoid noisy warnings during npm test
+    exports.events.setMaxListeners(100);
+}
+
+function SettingsError(reason, errorOrMessage) {
+    assert.strictEqual(typeof reason, 'string');
+    assert(errorOrMessage instanceof Error || typeof errorOrMessage === 'string' || typeof errorOrMessage === 'undefined');
+
+    Error.call(this);
+    Error.captureStackTrace(this, this.constructor);
+
+    this.name = this.constructor.name;
+    this.reason = reason;
+    if (typeof errorOrMessage === 'undefined') {
+        this.message = reason;
+    } else if (typeof errorOrMessage === 'string') {
+        this.message = errorOrMessage;
+    } else {
+        this.message = 'Internal error';
+        this.nestedError = errorOrMessage;
+    }
+}
+util.inherits(SettingsError, Error);
+SettingsError.INTERNAL_ERROR = 'Internal Error';
+SettingsError.NOT_FOUND = 'Not Found';
+SettingsError.BAD_FIELD = 'Bad Field';
+
+function setAutoupdatePattern(pattern, callback) {
+    assert.strictEqual(typeof pattern, 'string');
+    assert.strictEqual(typeof callback, 'function');
+
+    if (pattern !== 'never') { // check if pattern is valid
+        var job = safe.safeCall(function () { return new CronJob(pattern); });
+        if (!job) return callback(new SettingsError(SettingsError.BAD_FIELD, 'Invalid pattern'));
+    }
+
+    settingsdb.set(exports.AUTOUPDATE_PATTERN_KEY, pattern, function (error) {
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+
+        exports.events.emit(exports.AUTOUPDATE_PATTERN_KEY, pattern);
+
+        return callback(null);
+    });
+}
+
+function getAutoupdatePattern(callback) {
+    assert.strictEqual(typeof callback, 'function');
+
+    settingsdb.get(exports.AUTOUPDATE_PATTERN_KEY, function (error, pattern) {
+        if (error && error.reason === DatabaseError.NOT_FOUND) return callback(null, gDefaults[exports.AUTOUPDATE_PATTERN_KEY]);
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+
+        callback(null, pattern);
+    });
+}
+
+function setTimeZone(tz, callback) {
+    assert.strictEqual(typeof tz, 'string');
+    assert.strictEqual(typeof callback, 'function');
+
+    settingsdb.set(exports.TIME_ZONE_KEY, tz, function (error) {
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+
+        exports.events.emit(exports.TIME_ZONE_KEY, tz);
+
+        return callback(null);
+    });
+}
+
+function getTimeZone(callback) {
+    assert.strictEqual(typeof callback, 'function');
+
+    settingsdb.get(exports.TIME_ZONE_KEY, function (error, tz) {
+        if (error && error.reason === DatabaseError.NOT_FOUND) return callback(null, gDefaults[exports.AUTOUPDATE_PATTERN_KEY]);
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+
+        callback(null, tz);
+    });
+}
+
+function getCloudronName(callback) {
+    assert.strictEqual(typeof callback, 'function');
+
+    settingsdb.get(exports.CLOUDRON_NAME_KEY, function (error, name) {
+        if (error && error.reason === DatabaseError.NOT_FOUND) return callback(null, gDefaults[exports.CLOUDRON_NAME_KEY]);
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+        callback(null, name);
+    });
+}
+
+function setCloudronName(name, callback) {
+    assert.strictEqual(typeof name, 'string');
+    assert.strictEqual(typeof callback, 'function');
+
+    if (!name) return callback(new SettingsError(SettingsError.BAD_FIELD));
+
+    settingsdb.set(exports.CLOUDRON_NAME_KEY, name, function (error) {
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+
+        exports.events.emit(exports.CLOUDRON_NAME_KEY, name);
+
+        return callback(null);
+    });
+}
+
+function getCloudronAvatar(callback) {
+    assert.strictEqual(typeof callback, 'function');
+
+    var avatar = safe.fs.readFileSync(paths.CLOUDRON_AVATAR_FILE);
+    if (avatar) return callback(null, avatar);
+
+    // try default fallback
+    avatar = safe.fs.readFileSync(paths.CLOUDRON_DEFAULT_AVATAR_FILE);
+    if (avatar) return callback(null, avatar);
+
+    callback(new SettingsError(SettingsError.INTERNAL_ERROR, safe.error));
+}
+
+function setCloudronAvatar(avatar, callback) {
+    assert(util.isBuffer(avatar));
+    assert.strictEqual(typeof callback, 'function');
+
+    if (!safe.fs.writeFileSync(paths.CLOUDRON_AVATAR_FILE, avatar)) {
+        return callback(new SettingsError(SettingsError.INTERNAL_ERROR, safe.error));
+    }
+
+    return callback(null);
+}
+
+function getDefaultSync(name) {
+    assert.strictEqual(typeof name, 'string');
+
+    return gDefaults[name];
+}
+
+function getAll(callback) {
+    assert.strictEqual(typeof callback, 'function');
+
+    settingsdb.getAll(function (error, settings) {
+        if (error) return callback(new SettingsError(SettingsError.INTERNAL_ERROR, error));
+
+        var result = _.extend({ }, gDefaults);
+        settings.forEach(function (setting) { result[setting.name] = setting.value; });
+
+        callback(null, result);
+    });
+}