@iobroker/js-controller-cli 4.0.21 → 4.1.0-alpha.0-20220819-74ceeddc

package/build/lib/setup/setupBackup.js

@@ -0,0 +1,1031 @@
+"use strict";
+/**
+ *      Backup
+ *
+ *      Copyright 2013-2022 bluefox <dogafox@gmail.com>
+ *
+ *      MIT License
+ *
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupRestore = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_controller_common_1 = require("@iobroker/js-controller-common");
+const path_1 = __importDefault(require("path"));
+const setupUpload_1 = require("./setupUpload");
+const js_controller_common_2 = require("@iobroker/js-controller-common");
+const promisify_child_process_1 = __importDefault(require("promisify-child-process"));
+const tar_1 = __importDefault(require("tar"));
+const hostname = js_controller_common_1.tools.getHostName();
+const controllerDir = js_controller_common_1.tools.getControllerDir();
+const tmpDir = path_1.default.normalize(path_1.default.join(controllerDir, 'tmp'));
+const bkpDir = path_1.default.normalize(path_1.default.join(controllerDir, 'backups'));
+class BackupRestore {
+    constructor(options) {
+        options = options || {};
+        if (!options.states) {
+            throw new Error('Invalid arguments: states is missing');
+        }
+        if (!options.objects) {
+            throw new Error('Invalid arguments: objects is missing');
+        }
+        if (!options.processExit) {
+            throw new Error('Invalid arguments: processExit is missing');
+        }
+        if (!options.cleanDatabase) {
+            throw new Error('Invalid arguments: cleanDatabase is missing');
+        }
+        if (!options.restartController) {
+            throw new Error('Invalid arguments: restartController is missing');
+        }
+        this.objects = options.objects;
+        this.states = options.states;
+        this.processExit = options.processExit;
+        this.cleanDatabase = options.cleanDatabase;
+        this.restartController = options.restartController;
+        this.dbMigration = options.dbMigration || false;
+        this.PRESERVE_ADAPTERS = ['admin', 'backitup'];
+        this.upload = new setupUpload_1.Upload(options);
+        this.configParts = js_controller_common_1.tools.getConfigFileName().split('/');
+        this.configParts.pop(); // remove *.json
+        this.configDir = this.configParts.join('/'); // => name-data
+    }
+    // --------------------------------------- BACKUP ---------------------------------------------------
+    async _copyFile(id, srcPath, destPath) {
+        try {
+            // @ts-expect-error #1917
+            const data = await this.objects.readFileAsync(id, srcPath);
+            if (data) {
+                if (data.data !== undefined) {
+                    fs_extra_1.default.writeFileSync(destPath, data.data);
+                }
+                else {
+                    // @ts-expect-error #1917 revisit
+                    fs_extra_1.default.writeFileSync(destPath, data);
+                }
+            }
+        }
+        catch (err) {
+            console.log(`Can not copy File ${id}${srcPath} to ${destPath}: ${err.message}`);
+        }
+    }
+    async copyDir(id, srcPath, destPath) {
+        !fs_extra_1.default.existsSync(destPath) && fs_extra_1.default.mkdirSync(destPath);
+        try {
+            // @ts-expect-error #1917
+            const res = await this.objects.readDirAsync(id, srcPath);
+            if (res) {
+                for (const entry of res) {
+                    if (entry.isDir) {
+                        await this.copyDir(id, `${srcPath}/${entry.file}`, `${destPath}/${entry.file}`);
+                    }
+                    else {
+                        fs_extra_1.default.ensureDirSync(destPath);
+                        await this._copyFile(id, `${srcPath}/${entry.file}`, `${destPath}/${entry.file}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (!err.message.includes('Not exists')) {
+                console.warn(`Directory ${id}/${srcPath} cannot be copied: ${err}`);
+            }
+        }
+    }
+    static getBackupDir() {
+        const dataDir = path_1.default.join(controllerDir, js_controller_common_1.tools.getDefaultDataDir());
+        const parts = dataDir.split('/');
+        parts.pop(); // remove data or appName-data
+        parts.pop();
+        return path_1.default.normalize(`${parts.join('/')}/backups/`);
+    }
+    copyFileSync(source, target) {
+        let targetFile = target;
+        try {
+            // if target is a directory a new file with the same name will be created
+            if (fs_extra_1.default.existsSync(target)) {
+                if (fs_extra_1.default.statSync(target).isDirectory()) {
+                    targetFile = path_1.default.join(target, path_1.default.basename(source));
+                }
+            }
+            fs_extra_1.default.writeFileSync(targetFile, fs_extra_1.default.readFileSync(source));
+        }
+        catch (e) {
+            console.error(`Could not copy ${targetFile} to ${source}: ${e.message}`);
+        }
+    }
+    copyFolderRecursiveSync(source, target) {
+        let files = [];
+        if (!fs_extra_1.default.existsSync(target)) {
+            fs_extra_1.default.mkdirSync(target);
+        }
+        // check if folder needs to be created or integrated
+        const targetFolder = path_1.default.join(target, path_1.default.basename(source));
+        if (!fs_extra_1.default.existsSync(targetFolder)) {
+            fs_extra_1.default.mkdirSync(targetFolder);
+        }
+        // copy
+        if (fs_extra_1.default.existsSync(source) && fs_extra_1.default.statSync(source).isDirectory()) {
+            files = fs_extra_1.default.readdirSync(source);
+            files.forEach(file => {
+                const curSource = path_1.default.join(source, file);
+                if (!fs_extra_1.default.existsSync(curSource)) {
+                    return;
+                }
+                if (fs_extra_1.default.statSync(curSource).isDirectory()) {
+                    this.copyFolderRecursiveSync(curSource, targetFolder);
+                }
+                else {
+                    this.copyFileSync(curSource, targetFolder);
+                }
+            });
+        }
+    }
+    /**
+     * Pack and compress the backup
+     *
+     * @param name - backup name
+     */
+    _packBackup(name) {
+        // 2021_10_25 BF (TODO): store letsencrypt files too
+        const letsEncrypt = `${this.configDir}/letsencrypt`;
+        if (fs_extra_1.default.existsSync(letsEncrypt)) {
+            this.copyFolderRecursiveSync(letsEncrypt, `${tmpDir}/backup`);
+        }
+        return new Promise(resolve => {
+            const f = fs_extra_1.default.createWriteStream(name);
+            f.on('finish', () => {
+                js_controller_common_1.tools.rmdirRecursiveSync(`${tmpDir}/backup`);
+                resolve(path_1.default.normalize(name));
+            });
+            f.on('error', err => {
+                console.error(`host.${hostname} Cannot pack directory ${tmpDir}/backup: ${err.message}`);
+                this.processExit(js_controller_common_2.EXIT_CODES.CANNOT_GZIP_DIRECTORY);
+            });
+            try {
+                tar_1.default.create({ gzip: true, cwd: `${tmpDir}/` }, ['backup']).pipe(f);
+            }
+            catch (err) {
+                console.error(`host.${hostname} Cannot pack directory ${tmpDir}/backup: ${err.message}`);
+                return void this.processExit(js_controller_common_2.EXIT_CODES.CANNOT_GZIP_DIRECTORY);
+            }
+        });
+    }
+    /**
+     * Creates backup and stores with given name
+     *
+     * @param name - name of the backup
+     * @param noConfig - do not store configs
+     */
+    async createBackup(name, noConfig) {
+        var _a;
+        if (!name) {
+            const d = new Date();
+            name =
+                d.getFullYear() +
+                    '_' +
+                    ('0' + (d.getMonth() + 1)).slice(-2) +
+                    '_' +
+                    ('0' + d.getDate()).slice(-2) +
+                    '-' +
+                    ('0' + d.getHours()).slice(-2) +
+                    '_' +
+                    ('0' + d.getMinutes()).slice(-2) +
+                    '_' +
+                    ('0' + d.getSeconds()).slice(-2) +
+                    `_backup${js_controller_common_1.tools.appName}`;
+        }
+        name = name.toString().replace(/\\/g, '/');
+        if (!name.includes('/')) {
+            const backupPath = BackupRestore.getBackupDir();
+            // create directory if not exists
+            if (!fs_extra_1.default.existsSync(backupPath)) {
+                fs_extra_1.default.mkdirSync(backupPath);
+            }
+            if (!name.includes('.tar.gz')) {
+                name = `${backupPath + name}.tar.gz`;
+            }
+            else {
+                name = backupPath + name;
+            }
+        }
+        let result = { objects: null, states: {} };
+        const hostname = js_controller_common_1.tools.getHostName();
+        try {
+            // @ts-expect-error #1917
+            const res = await this.objects.getObjectListAsync({ include_docs: true });
+            if (res) {
+                result.objects = res.rows;
+            }
+        }
+        catch (e) {
+            console.error(`host.${hostname} Cannot get objects: ${e.message}`);
+        }
+        if (!noConfig) {
+            result.config = null;
+        }
+        if (!noConfig && fs_extra_1.default.existsSync(js_controller_common_1.tools.getConfigFileName())) {
+            result.config = fs_extra_1.default.readJSONSync(js_controller_common_1.tools.getConfigFileName());
+        }
+        const r = new RegExp(`^system\\.host\\.${hostname}\\.(\\w+)$`);
+        try {
+            // @ts-expect-error #1917
+            const keys = await this.states.getKeys('*');
+            // NOTE for all "replace" with $$$$ ... result will be just $$
+            // @ts-expect-error #1917
+            const objs = await this.states.getStates(keys);
+            // read iobroker.json
+            let isCustomHostname;
+            try {
+                const config = await fs_extra_1.default.readJSON(js_controller_common_1.tools.getConfigFileName());
+                // if a hostname is configured
+                isCustomHostname = !!config.system.hostname;
+            }
+            catch (e) {
+                console.error(`host.${hostname} Cannot read config file: ${e.message}`);
+            }
+            if (keys && objs) {
+                for (let i = 0; i < keys.length; i++) {
+                    const obj = objs[i];
+                    if (!obj) {
+                        continue;
+                    }
+                    if (!isCustomHostname) {
+                        // if its a default hostname, we will have a new default after restore and need to replace
+                        if (obj.from === `system.host.${hostname}` || r.test(obj.from)) {
+                            obj.from.replace(`system.host.${hostname}`, 'system.host.$$$$__hostname__$$$$');
+                        }
+                        if (r.test(keys[i])) {
+                            keys[i] = keys[i].replace(hostname, '$$$$__hostname__$$$$');
+                        }
+                    }
+                    result.states[keys[i]] = obj;
+                }
+                console.log(`host.${hostname} ${keys.length} states saved`);
+            }
+        }
+        catch (e) {
+            console.error(`host.${hostname} Cannot get states: ${e.message}`);
+        }
+        if (!fs_extra_1.default.existsSync(bkpDir)) {
+            fs_extra_1.default.mkdirSync(bkpDir);
+        }
+        if (!fs_extra_1.default.existsSync(tmpDir)) {
+            fs_extra_1.default.mkdirSync(tmpDir);
+        }
+        try {
+            js_controller_common_1.tools.rmdirRecursiveSync(`${tmpDir}/backup/`);
+        }
+        catch (e) {
+            console.error(`host.${hostname} Cannot clear temporary backup directory: ${e.message}`);
+        }
+        if (!fs_extra_1.default.existsSync(`${tmpDir}/backup`)) {
+            fs_extra_1.default.mkdirSync(`${tmpDir}/backup`);
+        }
+        if (!fs_extra_1.default.existsSync(`${tmpDir}/backup/files`)) {
+            fs_extra_1.default.mkdirSync(`${tmpDir}/backup/files`);
+        }
+        // try to find user files
+        if (result.objects) {
+            for (const object of result.objects) {
+                if (!object || !object.value || !object.value._id || !object.value.common) {
+                    continue;
+                }
+                if (object.value._id.match(/^system\.adapter\.([\w\d_-]+).(\d+)$/) &&
+                    object.value.common.host === hostname) {
+                    object.value.common.host = '$$__hostname__$$';
+                    if (object.doc) {
+                        object.doc.common.host = '$$__hostname__$$';
+                    }
+                }
+                else if (r.test(object.value._id)) {
+                    object.value._id = object.value._id.replace(hostname, '$$$$__hostname__$$$$');
+                    object.id = object.value._id;
+                    if (object.doc) {
+                        object.doc._id = object.value._id;
+                    }
+                }
+                else if (object.value._id === 'system.host.' + hostname) {
+                    object.value._id = 'system.host.$$__hostname__$$';
+                    object.value.common.name = object.value._id;
+                    object.value.common.hostname = '$$__hostname__$$';
+                    if (object.value.native && object.value.native.os) {
+                        object.value.native.os.hostname = '$$__hostname__$$';
+                    }
+                    object.id = object.value._id;
+                    if (object.doc) {
+                        object.doc._id = object.value._id;
+                        object.doc.common.name = object.value._id;
+                        object.doc.common.hostname = '$$__hostname__$$';
+                        if (object.doc.native && object.value.native.os) {
+                            object.doc.native.os.hostname = '$$__hostname__$$';
+                        }
+                    }
+                }
+                // Read all files
+                if (object.value.type === 'meta' && object.value.common && object.value.common.type === 'meta.user') {
+                    // do not process "xxx.0. " and "xxx.0."
+                    if (object.id.trim() === object.id && object.id[object.id.length - 1] !== '.') {
+                        await this.copyDir(object.id, '', `${tmpDir}/backup/files/${object.id}`);
+                    }
+                }
+                // Read all files
+                if (object.value.type === 'instance' && object.value.common && object.value.common.dataFolder) {
+                    let dataFolderPath = object.value.common.dataFolder;
+                    if (dataFolderPath[0] !== '/' && !dataFolderPath.match(/^\w:/)) {
+                        dataFolderPath = path_1.default.join(this.configDir, dataFolderPath);
+                    }
+                    if (fs_extra_1.default.existsSync(dataFolderPath)) {
+                        this.copyFolderRecursiveSync(dataFolderPath, `${tmpDir}/backup`);
+                    }
+                }
+            }
+        }
+        // special case: copy vis vis-common-user.css file
+        try {
+            // @ts-expect-error #1917
+            const data = await this.objects.readFileAsync('vis', 'css/vis-common-user.css');
+            if (data) {
+                const dir = `${tmpDir}/backup/files/`;
+                !fs_extra_1.default.existsSync(`${dir}vis`) && fs_extra_1.default.mkdirSync(`${dir}vis`);
+                !fs_extra_1.default.existsSync(`${dir}vis/css`) && fs_extra_1.default.mkdirSync(`${dir}vis/css`);
+                // @ts-expect-error #1917
+                fs_extra_1.default.writeFileSync(`${dir}vis/css/vis-common-user.css`, data.data !== undefined ? data.data : data);
+            }
+        }
+        catch {
+            // do not process 'css/vis-common-user.css'
+        }
+        console.log(`host.${hostname} ${((_a = result.objects) === null || _a === void 0 ? void 0 : _a.length) || 'no'} objects saved`);
+        try {
+            fs_extra_1.default.writeFileSync(`${tmpDir}/backup/backup.json`, JSON.stringify(result, null, 2));
+            result = null; // ... to allow GC to clean it up because no longer needed
+            this._validateBackupAfterCreation();
+            return await this._packBackup(name);
+        }
+        catch (err) {
+            console.error(`host.${hostname} Backup not created: ${err.message}`);
+            try {
+                js_controller_common_1.tools.rmdirRecursiveSync(`${tmpDir}/backup/`);
+            }
+            catch (e) {
+                console.error(`host.${hostname} Cannot clear temporary backup directory: ${e.message}`);
+            }
+            return void this.processExit(js_controller_common_2.EXIT_CODES.CANNOT_EXTRACT_FROM_ZIP);
+        }
+    }
+    //--------------------------------------- RESTORE ---------------------------------------------------
+    /**
+     * Helper to restore raw states
+     *
+     * @param statesList - list of state ids
+     * @param stateObjects - list of state objects
+     */
+    async _setStateHelper(statesList, stateObjects) {
+        for (let i = 0; i < statesList.length; i++) {
+            try {
+                // @ts-expect-error #1917 TODO revisit after merge
+                await this.states.setRawState(statesList[i], stateObjects[statesList[i]]);
+            }
+            catch (err) {
+                console.log(`host.${hostname} Could not set value for state ${statesList[i]}: ${err.message}`);
+            }
+            if (i % 200 === 0) {
+                console.log(`host.${hostname} Processed ${i}/${statesList.length} states`);
+            }
+        }
+    }
+    /**
+     * Sets all objects to the db and disables all adapters
+     *
+     * @param _objects - array of all objects to be set
+     */
+    async _setObjHelper(_objects) {
+        for (let i = 0; i < _objects.length; i++) {
+            // Disable all adapters.
+            if (!this.dbMigration &&
+                _objects[i].id &&
+                /^system\.adapter\..+\.\d$/.test(_objects[i].id) &&
+                !_objects[i].id.startsWith('system.adapter.admin.') &&
+                !_objects[i].id.startsWith('system.adapter.backitup.')) {
+                if (_objects[i].doc.common && _objects[i].doc.common.enabled) {
+                    _objects[i].doc.common.enabled = false;
+                }
+            }
+            try {
+                await this.objects.setObjectAsync(_objects[i].id, _objects[i].doc);
+            }
+            catch (err) {
+                console.warn(`host.${hostname} Cannot restore ${_objects[i].id}: ${err.message}`);
+            }
+            if (i % 200 === 0) {
+                console.log(`host.${hostname} Processed ${i}/${_objects.length} objects`);
+            }
+        }
+    }
+    /**
+     * Creates all provided object if non existing
+     *
+     * @param objectList - list of objects to be created
+     */
+    async _reloadAdapterObject(objectList) {
+        if (!Array.isArray(objectList)) {
+            return;
+        }
+        for (const object of objectList) {
+            let obj;
+            try {
+                obj = await this.objects.getObjectAsync(object._id);
+            }
+            catch {
+                // ignore
+            }
+            if (!obj) {
+                // object not existing -> create it
+                try {
+                    await this.objects.setObjectAsync(object._id, object);
+                    console.log(`host.${hostname} object ${object._id} created`);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    async _reloadAdaptersObjects() {
+        const dirs = [];
+        let _modules;
+        let p = path_1.default.join(controllerDir, 'node_modules');
+        if (fs_extra_1.default.existsSync(p)) {
+            if (!p.includes('js-controller')) {
+                _modules = fs_extra_1.default.readdirSync(p).filter(dir => fs_extra_1.default.existsSync(`${p}/${dir}/io-package.json`));
+                if (_modules) {
+                    const regEx = new RegExp(`^${js_controller_common_1.tools.appName}\\.`, 'i');
+                    for (const module of _modules) {
+                        if (regEx.test(module) && !dirs.includes(module.substring(js_controller_common_1.tools.appName.length + 1))) {
+                            dirs.push(module);
+                        }
+                    }
+                }
+            }
+            else {
+                p = path_1.default.join(controllerDir, '..', 'node_modules');
+                if (fs_extra_1.default.existsSync(p)) {
+                    _modules = fs_extra_1.default.readdirSync(p).filter(dir => fs_extra_1.default.existsSync(`${p}/${dir}/io-package.json`));
+                    if (_modules) {
+                        const regEx = new RegExp(`^${js_controller_common_1.tools.appName}\\.`, 'i');
+                        for (const module of _modules) {
+                            if (regEx.test(module) && !dirs.includes(module.substring(js_controller_common_1.tools.appName.length + 1))) {
+                                dirs.push(module);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // if installed as npm
+        if (fs_extra_1.default.existsSync(path_1.default.join(controllerDir, '..', '..', 'node_modules', `${js_controller_common_1.tools.appName}.js-controller`))) {
+            const p = path_1.default.join(controllerDir, '..');
+            _modules = fs_extra_1.default.readdirSync(p).filter(dir => fs_extra_1.default.existsSync(`${p}/${dir}/io-package.json`));
+            const regEx_ = new RegExp(`^${js_controller_common_1.tools.appName}\\.`, 'i');
+            for (const module of _modules) {
+                // if starting from application name + '.'
+                if (regEx_.test(module) &&
+                    // If not js-controller
+                    module.substring(js_controller_common_1.tools.appName.length + 1) !== 'js-controller' &&
+                    !dirs.includes(module.substring(js_controller_common_1.tools.appName.length + 1))) {
+                    dirs.push(module);
+                }
+            }
+        }
+        for (const dir of dirs) {
+            const adapterName = dir.replace(/^iobroker\./i, '');
+            await this.upload.uploadAdapter(adapterName, false, true);
+            await this.upload.uploadAdapter(adapterName, true, true);
+            let pkg = null;
+            if (!dir) {
+                console.error('Wrong');
+            }
+            const adapterDir = js_controller_common_1.tools.getAdapterDir(adapterName);
+            if (fs_extra_1.default.existsSync(`${adapterDir}/io-package.json`)) {
+                pkg = fs_extra_1.default.readJSONSync(`${adapterDir}/io-package.json`);
+            }
+            if (pkg && pkg.objects && pkg.objects.length) {
+                console.log(`host.${hostname} Setup "${dir}" adapter`);
+                await this._reloadAdapterObject(pkg.objects);
+            }
+        }
+    }
+    async _uploadUserFiles(root, uploadPath) {
+        uploadPath = uploadPath || '';
+        if (!fs_extra_1.default.existsSync(root)) {
+            return;
+        }
+        const files = fs_extra_1.default.readdirSync(root + uploadPath);
+        for (const file of files) {
+            const fName = path_1.default.join(root, uploadPath, file);
+            if (!fs_extra_1.default.existsSync(fName)) {
+                continue;
+            }
+            const stat = fs_extra_1.default.statSync(fName);
+            if (stat.isDirectory()) {
+                try {
+                    await this._uploadUserFiles(root, `${uploadPath}/${file}`);
+                }
+                catch (err) {
+                    console.error(`Error: ${err}`);
+                }
+            }
+            else {
+                const parts = uploadPath.split('/');
+                const adapter = parts.splice(0, 2)[1];
+                const _path = `${parts.join('/')}/${file}`;
+                console.log(`host.${hostname} Upload user file "${adapter}/${_path}`);
+                try {
+                    await this.objects.writeFileAsync(adapter, _path, fs_extra_1.default.readFileSync(`${root + uploadPath}/${file}`));
+                }
+                catch (err) {
+                    console.error(`Error: ${err.message}`);
+                }
+            }
+        }
+    }
+    _copyBackupedFiles(backupDir) {
+        try {
+            if (!fs_extra_1.default.existsSync(backupDir)) {
+                console.log('No additional files to restore');
+                return;
+            }
+            const dirs = fs_extra_1.default.readdirSync(backupDir);
+            dirs.forEach(dir => {
+                if (dir === 'files') {
+                    return;
+                }
+                const backupPath = path_1.default.join(backupDir, dir);
+                let stat;
+                try {
+                    if (!fs_extra_1.default.existsSync(backupPath)) {
+                        return;
+                    }
+                    stat = fs_extra_1.default.statSync(backupPath);
+                }
+                catch (err) {
+                    console.error(`Ignoring ${backupPath} because can not get file type: ${err.message}`);
+                    return;
+                }
+                if (stat.isDirectory()) {
+                    this.copyFolderRecursiveSync(backupPath, this.configDir);
+                }
+            });
+        }
+        catch (err) {
+            console.error(`Ignoring ${backupDir} because can not read directory: ${err.message}`);
+        }
+    }
+    /**
+     * Restore after controller has been stopped
+     *
+     * @param restartOnFinish - restart controller after restore
+     * @param force - skip the controller version check
+     * @param dontDeleteAdapters - skip adapter deletion, e.g. for setup custom db migration
+     */
+    async _restoreAfterStop(restartOnFinish, force, dontDeleteAdapters) {
+        // Open file
+        let data = fs_extra_1.default.readFileSync(`${tmpDir}/backup/backup.json`, 'utf8');
+        const hostname = js_controller_common_1.tools.getHostName();
+        // replace all hostnames of instances etc with the new host
+        data = data.replace(/\$\$__hostname__\$\$/g, hostname);
+        fs_extra_1.default.writeFileSync(`${tmpDir}/backup/backup_.json`, data);
+        let restore;
+        try {
+            restore = JSON.parse(data);
+        }
+        catch (err) {
+            console.error(`Cannot parse "${tmpDir}/backup/backup_.json": ${err.message}`);
+            return js_controller_common_2.EXIT_CODES.CANNOT_RESTORE_BACKUP;
+        }
+        // check that the same controller version is installed as it is contained in backup
+        const exitCode = this._ensureCompatibility(controllerDir, restore.config ? restore.config.system.hostname || hostname : hostname, restore.objects, force);
+        if (exitCode) {
+            // we had an error
+            return exitCode;
+        }
+        if (!dontDeleteAdapters) {
+            // prevent having wrong versions of adapters
+            await this._removeAllAdapters();
+        }
+        // stop all adapters
+        console.log(`host.${hostname} Clear all objects and states...`);
+        await this.cleanDatabase(false);
+        console.log(`host.${hostname} done.`);
+        // upload all data into DB
+        // restore ioBroker.json
+        if (restore.config) {
+            fs_extra_1.default.writeFileSync(js_controller_common_1.tools.getConfigFileName(), JSON.stringify(restore.config, null, 2));
+        }
+        const sList = Object.keys(restore.states);
+        await this._setObjHelper(restore.objects);
+        console.log(`${restore.objects.length} objects restored.`);
+        await this._setStateHelper(sList, restore.states);
+        console.log(`${sList.length} states restored.`);
+        // Load user files into DB
+        await this._uploadUserFiles(`${tmpDir}/backup/files`);
+        // reload objects of adapters (if some couldn't be removed - normally this shouldn't be necessary anymore)
+        await this._reloadAdaptersObjects();
+        // Reload host objects
+        const packageIO = fs_extra_1.default.readJSONSync(path_1.default.join(controllerDir, 'io-package.json'));
+        await this._reloadAdapterObject(packageIO ? packageIO.objects : null);
+        // copy all files into iob-data
+        await this._copyBackupedFiles(path_1.default.join(tmpDir, 'backup'));
+        // reinstall preserve adapters
+        await this._restorePreservedAdapters();
+        if (force) {
+            // js-controller version has changed (setup never called for this version)
+            console.log('Forced restore - executing setup ...');
+            try {
+                await promisify_child_process_1.default.exec(`"${process.execPath}" "${path_1.default.join(controllerDir, `${js_controller_common_1.tools.appName.toLowerCase()}.js`)}" setup`);
+            }
+            catch (e) {
+                console.error(`Could not execute "setup" command, please ensure "setup" is called before starting ioBroker: ${e.message}`);
+            }
+        }
+        if (restartOnFinish) {
+            this.restartController();
+        }
+        return js_controller_common_2.EXIT_CODES.NO_ERROR;
+    }
+    /**
+     * Removes all adapters
+     */
+    async _removeAllAdapters() {
+        const nodeModulePath = path_1.default.join(controllerDir, '..');
+        const nodeModuleDirs = fs_extra_1.default.readdirSync(nodeModulePath, { withFileTypes: true });
+        // we need to uninstall current adapters to get exact the same system as before backup
+        for (const dir of nodeModuleDirs) {
+            if (dir.isDirectory() &&
+                dir.name.startsWith(`${js_controller_common_1.tools.appName.toLowerCase()}.`) &&
+                dir.name !== `${js_controller_common_1.tools.appName.toLowerCase()}.js-controller`) {
+                try {
+                    const packJson = fs_extra_1.default.readJsonSync(path_1.default.join(nodeModulePath, dir.name, 'package.json'));
+                    console.log(`Removing current installation of ${packJson.name}`);
+                    await js_controller_common_1.tools.uninstallNodeModule(packJson.name);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    /**
+     * Ensure that installed controller version matches version in backup
+     *
+     * @param controllerDir - directory of js-controller
+     * @param backupHostname - hostname in backup file
+     * @param backupObjects - the objects contained in the backup
+     * @param force - if force is true, only log
+     */
+    _ensureCompatibility(controllerDir, backupHostname, backupObjects, force) {
+        try {
+            const ioPackJson = fs_extra_1.default.readJsonSync(path_1.default.join(controllerDir, 'io-package.json'));
+            const hostObj = backupObjects.find(obj => obj.id === `system.host.${backupHostname}`);
+            if (!hostObj) {
+                console.error('No host object found, your backup seems to be corrupted!');
+                return js_controller_common_2.EXIT_CODES.CANNOT_RESTORE_BACKUP;
+            }
+            if (hostObj.value.common.installedVersion !== ioPackJson.common.version) {
+                if (!force) {
+                    console.warn('The current version of js-controller differs from the version in the backup.');
+                    console.warn('The js-controller version of the backup can not be restored automatically.');
+                    console.warn(`To restore the js-controller version of the backup, execute "npm i iobroker.js-controller@${hostObj.value.common.installedVersion} --production" inside your ioBroker directory`);
+                    console.warn('If you really want to restore the backup with the current installed js-controller, execute the restore command with the --force flag');
+                    return js_controller_common_2.EXIT_CODES.CANNOT_RESTORE_BACKUP;
+                }
+                else {
+                    console.info('The current version of js-controller differs from the version in the backup.');
+                    console.info('The js-controller version of the backup can not be restored automatically.');
+                    console.info('Note, that your backup might differ in behavior due to this version change!');
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    /**
+     * Returns all backups as array
+     */
+    listBackups() {
+        const dir = BackupRestore.getBackupDir();
+        const result = [];
+        if (fs_extra_1.default.existsSync(dir)) {
+            const files = fs_extra_1.default.readdirSync(dir);
+            for (const file of files) {
+                if (file.match(/\.tar\.gz$/i)) {
+                    result.push(file);
+                }
+            }
+            return result;
+        }
+        else {
+            return result;
+        }
+    }
+    /**
+     * Validates the backup.json and all json files inside the backup after (in temporary directory), here we only abort if backup.json is corrupted
+     */
+    _validateBackupAfterCreation() {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const backupJSON = require(`${tmpDir}/backup/backup.json`);
+        if (!backupJSON.objects || !backupJSON.objects.length) {
+            throw new Error('Backup does not contain valid objects');
+        }
+        // we check all other json files, we assume them as optional, because user created files may be no valid json
+        try {
+            this._checkDirectory(`${tmpDir}/backup/files`);
+        }
+        catch (err) {
+            console.warn(`host.${hostname} One or more optional files are corrupted: ${err.message}`);
+            console.warn(`host.${hostname} Please ensure that self-created JSON files are valid`);
+        }
+    }
+    /**
+     * Validates the given backup.json and all json files in the backup, calls processExit afterwards
+     * @param _name - index or name of the backup
+     */
+    validateBackup(_name) {
+        let backups;
+        let name = typeof _name === 'number' ? _name.toString() : _name;
+        if (!name) {
+            backups = this.listBackups();
+            backups.sort((a, b) => (b > a ? 1 : b === a ? 0 : -1));
+            if (backups.length) {
+                // List all available backups
+                console.log('Please specify one of the backup names:');
+                for (const t in backups) {
+                    console.log(`${backups[t]} or ${backups[t].replace(`_backup${js_controller_common_1.tools.appName}.tar.gz`, '')} or ${t}`);
+                }
+            }
+            else {
+                console.warn(`No backups found. Create a backup, using "${js_controller_common_1.tools.appName} backup" first`);
+            }
+            return void this.processExit(10);
+        }
+        // If number
+        if (parseInt(name, 10).toString() === name.toString()) {
+            backups = this.listBackups();
+            backups.sort((a, b) => (b > a ? 1 : b === a ? 0 : -1));
+            name = backups[parseInt(name, 10)];
+            if (!name) {
+                console.log('No matching backup found');
+                if (backups.length) {
+                    console.log('Please specify one of the backup names:');
+                    for (const t in backups) {
+                        console.log(`${backups[t]} or ${backups[t].replace(`_backup${js_controller_common_1.tools.appName}.tar.gz`, '')} or ${t}`);
+                    }
+                }
+                else {
+                    console.log(`No existing backups. Create a backup, using "${js_controller_common_1.tools.appName} backup" first`);
+                }
+                return void this.processExit(10);
+            }
+            else {
+                console.log(`host.${hostname} Using backup file ${name}`);
+            }
+        }
+        name = name.toString().replace(/\\/g, '/');
+        if (!name.includes('/')) {
+            name = BackupRestore.getBackupDir() + name;
+            const regEx = new RegExp(`_backup${js_controller_common_1.tools.appName}`, 'i');
+            if (!regEx.test(name)) {
+                name += `_backup${js_controller_common_1.tools.appName}`;
+            }
+            if (!name.match(/\.tar\.gz$/i)) {
+                name += '.tar.gz';
+            }
+        }
+        if (!fs_extra_1.default.existsSync(name)) {
+            console.error(`host.${hostname} Cannot find ${name}`);
+            return void this.processExit(11);
+        }
+        if (fs_extra_1.default.existsSync(`${tmpDir}/backup/backup.json`)) {
+            fs_extra_1.default.unlinkSync(`${tmpDir}/backup/backup.json`);
+        }
+        return new Promise(resolve => {
+            tar_1.default.extract({
+                file: name,
+                cwd: tmpDir
+            }, undefined, err => {
+                if (err) {
+                    console.error(`host.${hostname} Cannot extract from file "${name}": ${err.message}`);
+                    return void this.processExit(9);
+                }
+                if (!fs_extra_1.default.existsSync(`${tmpDir}/backup/backup.json`)) {
+                    console.error(`host.${hostname} Validation failed. Cannot find extracted file from file "${tmpDir}/backup/backup.json"`);
+                    return void this.processExit(9);
+                }
+                console.log(`host.${hostname} Starting validation ...`);
+                let backupJSON;
+                try {
+                    backupJSON = require(`${tmpDir}/backup/backup.json`);
+                }
+                catch (err) {
+                    console.error(`host.${hostname} Backup corrupted. Backup ${name} does not contain a valid backup.json file: ${err.message}`);
+                    try {
+                        js_controller_common_1.tools.rmdirRecursiveSync(`${tmpDir}/backup/`);
+                    }
+                    catch (e) {
+                        console.error(`host.${hostname} Cannot clear temporary backup directory: ${e.message}`);
+                    }
+                    return void this.processExit(26);
+                }
+                if (!backupJSON || !backupJSON.objects || !backupJSON.objects.length) {
+                    console.error(`host.${hostname} Backup corrupted. Backup does not contain valid objects`);
+                    try {
+                        js_controller_common_1.tools.rmdirRecursiveSync(`${tmpDir}/backup/`);
+                    }
+                    catch (e) {
+                        console.error(`host.${hostname} Cannot clear temporary backup directory: ${e.message}`);
+                    }
+                    return void this.processExit(26);
+                }
+                console.log(`host.${hostname} backup.json OK`);
+                try {
+                    this._checkDirectory(`${tmpDir}/backup/files`, true);
+                    try {
+                        js_controller_common_1.tools.rmdirRecursiveSync(`${tmpDir}/backup/`);
+                    }
+                    catch (e) {
+                        console.error(`host.${hostname} Cannot clear temporary backup directory: ${e.message}`);
+                    }
+                    resolve();
+                }
+                catch (err) {
+                    console.error(`host.${hostname} Backup corrupted: ${err.message}`);
+                    return void this.processExit(26);
+                }
+            });
+        });
+    }
+    /**
+     * Checks a directory for json files and validates them, steps down recursive in subdirectories
+     * @param path - path to the directory
+     * @param verbose - if logging should be verbose
+     */
+    _checkDirectory(path, verbose = false) {
+        if (fs_extra_1.default.existsSync(path)) {
+            const files = fs_extra_1.default.readdirSync(path);
+            if (!files.length) {
+                return;
+            }
+            for (const file of files) {
+                const filePath = `${path}/${file}`;
+                if (fs_extra_1.default.existsSync(filePath) && fs_extra_1.default.statSync(filePath).isDirectory()) {
+                    // if directory then check it
+                    this._checkDirectory(filePath, verbose);
+                }
+                else if (file.endsWith('.json')) {
+                    try {
+                        require(filePath);
+                        if (verbose) {
+                            console.log(`host.${hostname} ${file} OK`);
+                        }
+                    }
+                    catch {
+                        throw new Error(`host.${hostname} ${filePath} is not a valid json file`);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Restores a backup
+     *
+     * @param _name - backup name or index
+     * @param force - if force, js-controller is allowed to have a different version
+     * @param dontDeleteAdapters - skip adapter deletion, e.g. for setup custom db migration
+     * @param callback
+     */
+    restoreBackup(_name, force, dontDeleteAdapters, callback) {
+        let backups;
+        let name = typeof _name === 'number' ? _name.toString() : _name;
+        if (!name) {
+            // List all available backups
+            console.log('Please specify one of the backup names:');
+            backups = this.listBackups();
+            backups.sort((a, b) => (b > a ? 1 : b === a ? 0 : -1));
+            if (backups.length) {
+                backups.forEach((backup, i) => console.log(`${backup} or ${backup.replace(`_backup${js_controller_common_1.tools.appName}.tar.gz`, '')} or ${i}`));
+            }
+            else {
+                console.warn('No backups found');
+            }
+            return void this.processExit(10);
+        }
+        if (!this.cleanDatabase) {
+            throw new Error('Invalid arguments: cleanDatabase is missing');
+        }
+        if (!this.restartController) {
+            throw new Error('Invalid arguments: restartController is missing');
+        }
+        // If number
+        if (parseInt(name, 10).toString() === name.toString()) {
+            backups = this.listBackups();
+            backups.sort((a, b) => (b > a ? 1 : b === a ? 0 : -1));
+            name = backups[parseInt(name, 10)];
+            if (!name) {
+                console.log('No matching backup found');
+                if (backups.length) {
+                    console.log('Please specify one of the backup names:');
+                    backups.forEach((backup, i) => console.log(`${backup} or ${backup.replace(`_backup${js_controller_common_1.tools.appName}.tar.gz`, '')} or ${i}`));
+                }
+            }
+            else {
+                console.log(`host.${hostname} Using backup file ${name}`);
+            }
+        }
+        name = name.toString().replace(/\\/g, '/');
+        if (!name.includes('/')) {
+            name = BackupRestore.getBackupDir() + name;
+            const regEx = new RegExp(`_backup${js_controller_common_1.tools.appName}`, 'i');
+            if (!regEx.test(name)) {
+                name += '_backup' + js_controller_common_1.tools.appName;
+            }
+            if (!name.match(/\.tar\.gz$/i)) {
+                name += '.tar.gz';
+            }
+        }
+        if (!fs_extra_1.default.existsSync(name)) {
+            console.error(`host.${hostname} Cannot find ${name}`);
+            return void this.processExit(11);
+        }
+        // delete /backup/backup.json
+        fs_extra_1.default.existsSync(`${tmpDir}/backup/backup.json`) && fs_extra_1.default.unlinkSync(`${tmpDir}/backup/backup.json`);
+        tar_1.default.extract({
+            file: name,
+            cwd: tmpDir
+        }, undefined, err => {
+            if (err) {
+                console.error(`host.${hostname} Cannot extract from file "${name}": ${err.message}`);
+                return void this.processExit(9);
+            }
+            if (!fs_extra_1.default.existsSync(`${tmpDir}/backup/backup.json`)) {
+                console.error(`host.${hostname} Cannot find extracted file from file "${tmpDir}/backup/backup.json"`);
+                return void this.processExit(9);
+            }
+            // Stop controller
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const daemon = require('daemonize2').setup({
+                main: path_1.default.join(controllerDir, 'controller.js'),
+                name: `${js_controller_common_1.tools.appName} controller`,
+                pidfile: path_1.default.join(controllerDir, `${js_controller_common_1.tools.appName}.pid`),
+                cwd: controllerDir,
+                stopTimeout: 1000
+            });
+            daemon.on('error', async () => {
+                const exitCode = await this._restoreAfterStop(false, force, dontDeleteAdapters);
+                callback && callback(exitCode);
+            });
+            daemon.on('stopped', async () => {
+                const exitCode = await this._restoreAfterStop(true, force, dontDeleteAdapters);
+                callback && callback(exitCode);
+            });
+            daemon.on('notrunning', async () => {
+                console.log(`host.${hostname} OK.`);
+                const exitCode = await this._restoreAfterStop(false, force, dontDeleteAdapters);
+                callback && callback(exitCode);
+            });
+            daemon.stop();
+        });
+    }
+    /**
+     * This method checks if adapter of PRESERVE_ADAPTERS exist, and reinstalls them if this is the case
+     */
+    async _restorePreservedAdapters() {
+        for (const adapterName of this.PRESERVE_ADAPTERS) {
+            try {
+                const adapterObj = await this.objects.getObjectAsync(`system.adapter.${adapterName}`);
+                if (adapterObj && adapterObj.common && adapterObj.common.version) {
+                    let installSource;
+                    // @ts-expect-error https://github.com/ioBroker/adapter-core/issues/455
+                    if (adapterObj.common.installedFrom) {
+                        // @ts-expect-error https://github.com/ioBroker/adapter-core/issues/455
+                        installSource = adapterObj.common.installedFrom;
+                    }
+                    else {
+                        installSource = `${js_controller_common_1.tools.appName.toLowerCase()}.${adapterName}@${adapterObj.common.version}`;
+                    }
+                    console.log(`Reinstalling adapter "${adapterName}" from "${installSource}"`);
+                    await js_controller_common_1.tools.installNodeModule(installSource);
+                }
+            }
+            catch (e) {
+                console.error(`Could not ensure existence of adapter "${adapterName}": ${e.message}`);
+            }
+        }
+    }
+}
+exports.BackupRestore = BackupRestore;
+//# sourceMappingURL=setupBackup.js.map