cloudron-box/src/dashboard.js

'use strict';

exports = module.exports = {
    getLocation,
    setLocation,
    clearLocation,

    setupDnsAndCert,

    prepareLocation,
    setupLocation,

    getConfig,
};

const apps = require('./apps.js'),
    appstore = require('./appstore.js'),
    assert = require('assert'),
    BoxError = require('./boxerror.js'),
    branding = require('./branding.js'),
    constants = require('./constants.js'),
    debug = require('debug')('box:dashboard'),
    eventlog = require('./eventlog.js'),
    dns = require('./dns.js'),
    mailServer = require('./mailserver.js'),
    network = require('./network.js'),
    platform = require('./platform.js'),
    reverseProxy = require('./reverseproxy.js'),
    safe = require('safetydance'),
    settings = require('./settings.js'),
    system = require('./system.js'),
    tasks = require('./tasks.js'),
    users = require('./users.js');

async function getLocation() {
    const domain = await settings.get(settings.DASHBOARD_DOMAIN_KEY) || '';
    const fqdn = await settings.get(settings.DASHBOARD_FQDN_KEY) || '';

    return { domain, fqdn, subdomain: constants.DASHBOARD_SUBDOMAIN };
}

async function setLocation(domain) {
    assert.strictEqual(typeof domain, 'string');

    const fqdn = dns.fqdn(constants.DASHBOARD_SUBDOMAIN, domain);
    await settings.set(settings.DASHBOARD_DOMAIN_KEY, domain);
    await settings.set(settings.DASHBOARD_FQDN_KEY, fqdn);

    debug(`setLocation: ${domain || '<cleared>'}`);
}

async function clearLocation() {
    await setLocation('');
}

async function getConfig() {
    const ubuntuVersion = await system.getUbuntuVersion();
    const profileConfig = await users.getProfileConfig();
    const { fqdn:adminFqdn, domain:adminDomain } = await getLocation();

    // be picky about what we send out here since this is sent for 'normal' users as well
    return {
        apiServerOrigin: await appstore.getApiServerOrigin(),
        webServerOrigin: await appstore.getWebServerOrigin(),
        consoleServerOrigin: await appstore.getConsoleServerOrigin(),
        adminDomain,
        adminFqdn,
        mailFqdn: await mailServer.getLocation().fqdn,
        version: constants.VERSION,
        ubuntuVersion,
        isDemo: constants.DEMO,
        cloudronName: await branding.getCloudronName(),
        footer: await branding.renderFooter(),
        features: appstore.getFeatures(),
        profileLocked: profileConfig.lockUserProfiles,
        mandatory2FA: profileConfig.mandatory2FA,
    };
}

async function prepareLocation(domain, auditSource) {
    assert.strictEqual(typeof domain, 'string');
    assert.strictEqual(typeof auditSource, 'object');

    debug(`prepareLocation: ${domain}`);

    if (constants.DEMO) throw new BoxError(BoxError.CONFLICT, 'Not allowed in demo mode');

    const fqdn = dns.fqdn(constants.DASHBOARD_SUBDOMAIN, domain);
    const result = await apps.list();
    if (result.some(app => app.fqdn === fqdn)) throw new BoxError(BoxError.BAD_STATE, 'Dashboard location conflicts with an existing app');

    const taskId = await tasks.add(tasks.TASK_SETUP_DNS_AND_CERT, [ constants.DASHBOARD_SUBDOMAIN, domain, auditSource ]);
    tasks.startTask(taskId, {});

    return taskId;
}

async function setupLocation(domain, auditSource) {
    assert.strictEqual(typeof domain, 'string');
    assert.strictEqual(typeof auditSource, 'object');

    debug(`setupLocation: ${domain}`);

    if (constants.DEMO) throw new BoxError(BoxError.CONFLICT, 'Not allowed in demo mode');

    await reverseProxy.writeDashboardConfig(domain);
    const fqdn = dns.fqdn(constants.DASHBOARD_SUBDOMAIN, domain);

    await setLocation(domain);
    await safe(appstore.updateCloudron({ domain }), { debug });
    await eventlog.add(eventlog.ACTION_DASHBOARD_DOMAIN_UPDATE, auditSource, { domain, fqdn });
    await platform.onDashboardLocationChanged(auditSource);
}

async function setupDnsAndCert(subdomain, domain, auditSource, progressCallback) {
    assert.strictEqual(typeof subdomain, 'string');
    assert.strictEqual(typeof domain, 'string');
    assert.strictEqual(typeof auditSource, 'object');
    assert.strictEqual(typeof progressCallback, 'function');

    const dashboardFqdn = dns.fqdn(subdomain, domain);

    const ipv4 = await network.getIPv4();
    const ipv6 = await network.getIPv6();

    progressCallback({ percent: 20, message: `Updating DNS of ${dashboardFqdn}` });
    await dns.upsertDnsRecords(subdomain, domain, 'A', [ ipv4 ]);
    if (ipv6) await dns.upsertDnsRecords(subdomain, domain, 'AAAA', [ ipv6 ]);
    progressCallback({ percent: 40, message: `Waiting for DNS of ${dashboardFqdn}` });
    await dns.waitForDnsRecord(subdomain, domain, 'A', ipv4, { interval: 30000, times: 50000 });
    if (ipv6) await dns.waitForDnsRecord(subdomain, domain, 'AAAA', ipv6, { interval: 30000, times: 50000 });
    progressCallback({ percent: 60, message: `Getting certificate of ${dashboardFqdn}` });
    const location = { subdomain, domain, fqdn: dashboardFqdn, type: apps.LOCATION_TYPE_DASHBOARD, certificate: null };
    await reverseProxy.ensureCertificate(location, {}, auditSource);
}