379 lines
12 KiB
JavaScript
379 lines
12 KiB
JavaScript
/*
|
|
*
|
|
* This tests a flow for cloudron owner creating a selfhosted cloudron on digitalocean
|
|
* Owner creates a cloudron, activates it, installs and app and deletes the cloudron eventually
|
|
* We use a us-east-1 (US standard) backup bucket here
|
|
*
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var AppStore = require('../appstore.js'),
|
|
assert = require('assert'),
|
|
async = require('async'),
|
|
child_process = require('child_process'),
|
|
Cloudron = require('../cloudron.js'),
|
|
common = require('../common.js'),
|
|
digitalocean = require('../digitalocean.js'),
|
|
mailer = require('../mailer.js'),
|
|
rimraf = require('rimraf'),
|
|
semver = require('semver'),
|
|
sleep = require('../shell.js').sleep,
|
|
superagent = require('superagent'),
|
|
request = require('superagent-sync'),
|
|
util = require('util');
|
|
|
|
require('colors');
|
|
|
|
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
|
|
const BOX_VERSION = process.env.BOX_VERSION;
|
|
const DO_SELFHOST_DOMAIN = process.env.DO_SELFHOST_DOMAIN;
|
|
const DO_SSH_KEY = 'e2e_selfhost';
|
|
const DO_TYPE = '1gb';
|
|
const DO_REGION = 'nyc3';
|
|
const DO_IMAGE_SLUG = 'ubuntu-16-04-x64';
|
|
const BACKUP_KEY = 'somesecret';
|
|
const BACKUP_FOLDER = '/tmp/' + process.env.DO_SELFHOST_DOMAIN;
|
|
|
|
function machine(args, options) {
|
|
// https://github.com/nodejs/node-v0.x-archive/issues/9265
|
|
options = options || { };
|
|
args = util.isArray(args) ? args : args.match(/[^\s"]+|"([^"]+)"/g);
|
|
args = args.map(function (e) { return e[0] === '"' ? e.slice(1, -1) : e; }); // remove the quotes
|
|
|
|
console.log('cloudron machine ' + args.join(' '));
|
|
|
|
try {
|
|
var cp = child_process.spawnSync('cloudron', ['machine'].concat(args), { stdio: [ options.stdin || 'pipe', options.stdout || 'pipe', 'pipe' ], encoding: options.encoding || 'utf8' });
|
|
return cp;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
function cloudronCommand(args, options) {
|
|
// https://github.com/nodejs/node-v0.x-archive/issues/9265
|
|
options = options || { };
|
|
args = util.isArray(args) ? args : args.match(/[^\s"]+|"([^"]+)"/g);
|
|
args = args.map(function (e) { return e[0] === '"' ? e.slice(1, -1) : e; }); // remove the quotes
|
|
|
|
console.log('cloudron ' + args.join(' '));
|
|
|
|
try {
|
|
var cp = child_process.spawnSync('cloudron', args, { stdio: [ options.stdin || 'pipe', options.stdout || 'pipe', 'pipe' ], encoding: options.encoding || 'utf8' });
|
|
return cp;
|
|
} catch (e) {
|
|
console.error(e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
describe('Selfhost DigitalOcean with filesystem backend', function () {
|
|
this.timeout(0);
|
|
|
|
var appStore = new AppStore();
|
|
|
|
var owner = common.getOwner();
|
|
var cloudron, appId, backupInfo, instanceId, restoreInstanceId, migrateInstanceId;
|
|
var fromVersion, toVersion, nextVersion;
|
|
|
|
digitalocean.setCredentials(process.env.DIGITAL_OCEAN_TOKEN_STAGING);
|
|
|
|
it('can query versions', function () {
|
|
var res = request.get(process.env.BOX_VERSIONS_URL).end();
|
|
common.verifyResponse2xx(res);
|
|
var boxVersions = Object.keys(common.stripUnreachable(res.body)).sort(semver.rcompare);
|
|
fromVersion = boxVersions[2]; // we released a new version in before.js
|
|
toVersion = boxVersions[1];
|
|
assert.strictEqual(toVersion, BOX_VERSION);
|
|
nextVersion = boxVersions[0];
|
|
|
|
console.log('Will test update from %s to %s and then %s', fromVersion.yellow, toVersion.yellow, nextVersion.yellow);
|
|
});
|
|
|
|
it('can create a cloudron', function (done) {
|
|
digitalocean.create('tselfhost-filesystem-test', DO_IMAGE_SLUG, DO_SSH_KEY, DO_REGION, DO_TYPE, '', function (error, result) {
|
|
if (error) return done(error);
|
|
|
|
instanceId = result.id;
|
|
console.log('New instance created with id', instanceId);
|
|
|
|
var ip = null;
|
|
|
|
function waitForSSH() {
|
|
var params = [
|
|
'--cloudron ' + cloudron._box.ip,
|
|
'--ssh-key ' + DO_SSH_KEY,
|
|
'--ssh-port 22'
|
|
];
|
|
|
|
var out = machine('ssh ' + params.concat(['echo "hello"']).join(' '));
|
|
if (out.status === 0) return done();
|
|
|
|
setTimeout(waitForSSH, 2000);
|
|
}
|
|
|
|
function waitForDroplet() {
|
|
digitalocean.get(result.id, function (error, result) {
|
|
if (error) return done(error);
|
|
|
|
console.log('status', result.status);
|
|
|
|
ip = result.ip;
|
|
|
|
if (result.status === 'active') {
|
|
cloudron = new Cloudron({
|
|
domain: DO_SELFHOST_DOMAIN,
|
|
setupToken: null,
|
|
version: toVersion,
|
|
ip: result.ip
|
|
});
|
|
|
|
return waitForSSH();
|
|
}
|
|
|
|
setTimeout(waitForDroplet, 2000);
|
|
});
|
|
}
|
|
|
|
waitForDroplet();
|
|
});
|
|
});
|
|
|
|
it('can install the Cloudron', function () {
|
|
var params = [
|
|
'--cloudron ' + cloudron._box.ip,
|
|
'--ssh-key ' + DO_SSH_KEY,
|
|
'--ssh-port 22'
|
|
];
|
|
|
|
console.log('wget cloudron-setup');
|
|
var out = machine('ssh ' + params.concat(['wget https://cloudron.io/cloudron-setup']).join(' '));
|
|
console.log(out.stdout, out.stderr);
|
|
assert.strictEqual(out.status, 0);
|
|
|
|
console.log('chmod +x cloudron-setup');
|
|
out = machine('ssh ' + params.concat(['chmod +x cloudron-setup']).join(' '));
|
|
console.log(out.stdout, out.stderr);
|
|
assert.strictEqual(out.status, 0);
|
|
|
|
console.log('run cloudron-setup');
|
|
out = machine('ssh ' + params.concat(['"./cloudron-setup --provider digitalocean --prerelease --version ' + toVersion + ' --env staging --skip-reboot"']).join(' '));
|
|
console.log(out.stdout, out.stderr);
|
|
assert.strictEqual(out.status, 0);
|
|
|
|
console.log('reboot the server');
|
|
out = machine('ssh ' + params.concat(['systemctl reboot']).join(' '));
|
|
console.log(out.stdout, out.stderr);
|
|
});
|
|
|
|
it('can setup dns', function () {
|
|
cloudron = new Cloudron({
|
|
domain: DO_SELFHOST_DOMAIN,
|
|
setupToken: null,
|
|
version: toVersion,
|
|
ip: cloudron._box.ip
|
|
});
|
|
|
|
var dnsConfig = {
|
|
domain: process.env.DO_SELFHOST_DOMAIN,
|
|
provider: 'digitalocean',
|
|
token: process.env.DIGITAL_OCEAN_TOKEN_STAGING
|
|
};
|
|
|
|
cloudron.waitForBox(true);
|
|
cloudron.setupDns(dnsConfig);
|
|
});
|
|
|
|
it('can activate the box', function () {
|
|
cloudron.activate(owner);
|
|
});
|
|
|
|
it('can login to the box', function () {
|
|
var token = cloudron.getOauthToken(owner);
|
|
cloudron.setCredentials(owner.password, token);
|
|
|
|
var params = [
|
|
process.env.DO_SELFHOST_DOMAIN,
|
|
'--username ' + owner.username,
|
|
'--password ' + owner.password
|
|
];
|
|
|
|
var out = cloudronCommand('login ' + params.join(' '));
|
|
console.log(out.stdout, out.stderr);
|
|
|
|
assert.strictEqual(out.status, 0);
|
|
});
|
|
|
|
it('can take a breather', function () {
|
|
// do can be really slow to come up. the addon containers take their own sweet time (they are "async" with the box startup)
|
|
// we end up sending email even before the mail container is ready
|
|
sleep(30);
|
|
});
|
|
|
|
it('can enable email', function () {
|
|
cloudron.setEmailEnabled(true);
|
|
});
|
|
|
|
it('send mail to cloudron user', function (done) {
|
|
mailer.sendMailToCloudronUser(owner.username + '@' + DO_SELFHOST_DOMAIN, done);
|
|
});
|
|
|
|
it('did receive mail', function (done) {
|
|
cloudron.checkMail(owner, done);
|
|
});
|
|
|
|
var location = 'test' + (Math.random() * 10000).toFixed();
|
|
it('can install app', function () {
|
|
var manifest = appStore.getManifest(common.TESTAPP_ID, common.TESTAPP_VERSION);
|
|
appId = cloudron.installApp(location, manifest);
|
|
});
|
|
|
|
it('can populate the addons', function () {
|
|
cloudron.populateAddons(cloudron.appFqdn(location));
|
|
});
|
|
|
|
it('can check the addons', function () {
|
|
cloudron.checkAddons(cloudron.appFqdn(location), owner);
|
|
});
|
|
|
|
it('can set appstore config', function (done) {
|
|
var token = appStore.getAccessToken(owner);
|
|
appStore.setCredentials(owner.password, token);
|
|
var profile = appStore.getProfile();
|
|
console.dir(profile);
|
|
cloudron.setAppstoreConfig(profile.id, token);
|
|
});
|
|
|
|
it('can update the box', function () {
|
|
cloudron.checkForUpdates();
|
|
|
|
var params = [
|
|
'--cloudron ' + process.env.DO_SELFHOST_DOMAIN,
|
|
'--ssh-key ' + DO_SSH_KEY,
|
|
'--ssh-port 22'
|
|
];
|
|
|
|
var out = machine('update ' + params.join(' '));
|
|
console.log(out.stdout, out.stderr);
|
|
|
|
if (out.stdout.indexOf('Update successful') === -1) {
|
|
assert(false, 'Update failed');
|
|
}
|
|
});
|
|
|
|
it('wait for app to be ready', function () {
|
|
cloudron.waitForApp(appId);
|
|
});
|
|
|
|
it('can configure app', function () {
|
|
location = location + 'x';
|
|
cloudron.configureApp(appId, location);
|
|
});
|
|
|
|
it('can check the addons', function () {
|
|
cloudron.checkAddons(cloudron.appFqdn(location), owner);
|
|
});
|
|
|
|
it('can check dnsbl', function () {
|
|
cloudron.checkDnsbl(cloudron.appFqdn(location));
|
|
});
|
|
|
|
it('can reboot the cloudron', function () {
|
|
cloudron.reboot();
|
|
});
|
|
|
|
it('runs the app', function () {
|
|
cloudron.waitForApp(appId);
|
|
});
|
|
|
|
it('can check the addons', function () {
|
|
cloudron.checkAddons(cloudron.appFqdn(location), owner);
|
|
});
|
|
|
|
it('can check dnsbl', function () {
|
|
cloudron.checkDnsbl(cloudron.appFqdn(location));
|
|
});
|
|
|
|
it('can check mail', function (done) {
|
|
cloudron.checkMail(owner, done);
|
|
});
|
|
|
|
it('can backup the box', function () {
|
|
backupInfo = cloudron.backup();
|
|
assert.strictEqual(backupInfo.dependsOn.length, 1);
|
|
});
|
|
|
|
it('can list backups', function () {
|
|
var out = machine('backup list --cloudron ' + DO_SELFHOST_DOMAIN);
|
|
console.log(out.stdout, out.stderr);
|
|
|
|
var knownBackupIds= out.stdout.split('\n').filter(function (l) { return l.indexOf('box_') >= 0; }).map(function (l) { return l.split(' ')[0].trim(); });
|
|
|
|
console.log('Last backup ids:', knownBackupIds);
|
|
|
|
assert(knownBackupIds.some(function (id) { return id === backupInfo.id; }));
|
|
});
|
|
|
|
it('can download backups', function () {
|
|
var out = machine('backup download ' + DO_SELFHOST_DOMAIN + ' --backup-id ' + backupInfo.id + ' ' + BACKUP_FOLDER);
|
|
console.log(out.stdout, out.stderr);
|
|
|
|
if (out.stdout.indexOf(backupInfo.id) === -1) assert(false, 'Download failed');
|
|
|
|
// TODO verify the md5sum
|
|
});
|
|
|
|
// it('can restore the box', function () {
|
|
// var params = [
|
|
// '--fqdn ' + DO_SELFHOST_DOMAIN,
|
|
// // THOSE SHOULD BE STASHED IN THE CONFIG
|
|
// // '--type ' + DO_TYPE,
|
|
// // '--token ' + DO_TOKEN,
|
|
// // '--region ' + DO_REGION,
|
|
// // '--ssh-key ' + SSH_KEY,
|
|
// // '--backup-key ' + BACKUP_KEY,
|
|
// '--backup ' + backupInfo.id,
|
|
// '--backup-folder ' + BACKUP_FOLDER
|
|
// ];
|
|
|
|
// var out = machine('restore digitalocean ' + params.join(' '));
|
|
// console.log(out.stdout, out.stderr);
|
|
|
|
// if (out.stdout.indexOf('You can now use your Cloudron at') === -1) {
|
|
// assert(false, 'Restore failed');
|
|
// }
|
|
|
|
// restoreInstanceId = out.stdout.split('\n').filter(function (l) { return l.indexOf(' ID: ') !== -1; })[0].split(':')[1].trim();
|
|
|
|
// console.log('New instance created with ID', restoreInstanceId);
|
|
|
|
// rimraf.sync(BACKUP_FOLDER);
|
|
// });
|
|
|
|
it('runs the app', function () {
|
|
cloudron.waitForApp(appId);
|
|
});
|
|
|
|
it('can uninstall app', function () {
|
|
cloudron.uninstallApp(appId);
|
|
});
|
|
|
|
it('can delete the cloudron', function (done) {
|
|
console.log('Cleanup DO instances', instanceId, restoreInstanceId, migrateInstanceId);
|
|
|
|
// we ignore errors here
|
|
function deleteDroplet(id, callback) {
|
|
if (!id) return callback();
|
|
|
|
digitalocean.destroy(id, function (error) {
|
|
if (error) console.error(error.message);
|
|
callback();
|
|
});
|
|
}
|
|
|
|
async.each([ instanceId, restoreInstanceId, migrateInstanceId ], deleteDroplet, done);
|
|
});
|
|
});
|