@ps-aux/nodebup 0.12.0 → 0.13.0

package/lib/bup/dir/DirBackupController.js

@@ -23,22 +23,22 @@ let DirBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.
 
     _defineProperty(this, "log", (0, _logging.classObjLog)(this));
 
-    _defineProperty(this, "backup", inp => {
+    _defineProperty(this, "backup", async inp => {
       const storage = this.storageProvider.provide();
 
       const path = _Path.AbsPath.from(inp.path);
 
       this.log.info(`Backing up from ${path} to '${storage}'`);
-      storage.store(path);
+      await storage.store(path);
     });
 
-    _defineProperty(this, "restore", inp => {
+    _defineProperty(this, "restore", async inp => {
       const storage = this.storageProvider.provide();
 
       const path = _Path.AbsPath.from(inp.path);
 
       this.log.info(`Restoring from '${storage}' to ${path}`);
-      storage.restore(path);
+      await storage.restore(path);
     });
   }
 

package/lib/bup/pg/PgBackupController.js

@@ -19,34 +19,28 @@ var _logging = require("../../log/logging");
 
 var _Fs = require("../../fs/Fs");
 
-var _dec, _dec2, _dec3, _class, _class2, _temp;
+var _Postgres = require("../../tools/pg/Postgres");
+
+var _ContextSymbols = require("../../ctx/ContextSymbols");
+
+var _config = require("../../config");
+
+var _dec, _dec2, _dec3, _dec4, _class, _class2, _temp;
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-const parseConnectionUrl = url => {
-  var _url$match;
-
-  // TODO what if there are query params in the end?
-  const regex = /postgres:\/\/(?<username>.*):(?<password>.*)@(?<host>.*):(?<port>\d*)$/;
-  const match = (_url$match = url.match(regex)) === null || _url$match === void 0 ? void 0 : _url$match.groups;
-  if (!match || !match.username || !match.password || !match.host || !match.port) throw new Error(`The Postgres connection URL does not match required regex: ${regex.toString()}`);
-  return {
-    username: match.username,
-    password: match.password,
-    host: match.host,
-    port: parseInt(match.port, 10)
-  };
-};
-
-let PgBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _BackupStorageProvider.BackupStorageProvider === "undefined" ? Object : _BackupStorageProvider.BackupStorageProvider, typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _Zipper.Zipper === "undefined" ? Object : _Zipper.Zipper]), _dec(_class = _dec2(_class = _dec3(_class = (_temp = _class2 = class PgBackupController {
+let PgBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.AppConfig_)(target, undefined, 3);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _BackupStorageProvider.BackupStorageProvider === "undefined" ? Object : _BackupStorageProvider.BackupStorageProvider, typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _config.Config === "undefined" ? Object : _config.Config, typeof _Zipper.Zipper === "undefined" ? Object : _Zipper.Zipper]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = (_temp = _class2 = class PgBackupController {
   constructor( // private gpg: Gpg,
   // private ssh: SshKeyManager,
   fs, // private fsSyncer: FsSyncer,
   storageBackendProvider, // @inject(AppConfig_) private cfg: Config,
-  sh, zip) {
+  sh, cfg, zip) {
     this.fs = fs;
     this.storageBackendProvider = storageBackendProvider;
     this.sh = sh;
+    this.cfg = cfg;
     this.zip = zip;
 
     _defineProperty(this, "log", (0, _logging.classObjLog)(this));
@@ -57,43 +51,24 @@ let PgBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.m
       return fields.join('-');
     });
 
-    _defineProperty(this, "getVersion", version => version || PgBackupController.defaultPgVersion);
-
     _defineProperty(this, "backup", async ({
       pgUrl,
       pgBinDir,
       backupName
     }) => {
       const storage = this.storageBackendProvider.provide();
-      const connParams = parseConnectionUrl(pgUrl); // TODO validate url
-
-      this.log.info(`Backing up Postgres database @${connParams.host}`);
-
-      const dir = _Path.AbsPath.from(`/var/backup/bup/${backupName}/postgres`); // const dir = AbsPath.from('/var/foo')
+      const pg = new _Postgres.Postgres(this.sh, this.fs, {
+        binDir: pgBinDir
+      }); // TODO make the path configurable/overridable
 
+      const dir = _Path.AbsPath.from(`/tmp/backup/bup/${backupName}/postgres`);
 
       await this.fs.inNewDir(dir, async () => {
-        // const outputDir = AbsPath.from(dir)
         this.log.info('Processing Postgres backup'); // Don't forget that this itself might be run in docker
         // therefore volume mounts are not usable (will apply to the location at host)
 
         const file = PgBackupController.dumpFileName;
-        this.log.info(`Dumping data into ${file}`);
-        let cmd = `pg_dumpall -d ${pgUrl} `;
-
-        if (pgBinDir) {
-          cmd = this.addPgBinDir(cmd, pgBinDir);
-        }
-
-        await this.sh.asyncExec(`${cmd} > ${file}`, {
-          env: {
-            PGPASSWORD: connParams.password
-          },
-          cwd: dir.str()
-        }, {
-          stdout: o => this.log.trace(o),
-          stderr: o => this.log.error(o)
-        });
+        await pg.dumpAllDbs(pgUrl, dir.resolve(file));
         this.log.info(`Compressing ${file}`);
         await this.sh.asyncExec(`gzip -v ${file}`, {
           cwd: dir.str()
@@ -102,80 +77,40 @@ let PgBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.m
           stderr: o => this.log.info('gzip: ' + o)
         });
         this.log.info('Uploading');
-        storage.store(dir);
+        await storage.store(dir);
       });
     });
 
-    _defineProperty(this, "dumpFromDockerCmd", (pass, pgUrl, version) => {
-      const bashCmds = [`echo "*:*:*:*:${pass}" > ~/.pgpass`, `chmod 400 ~/.pgpass`, `pg_dumpall -d ${pgUrl}`]; // Restore docker command
-      // this.sh.exec(
-      //     `gzip --decompress --stdout ${zipFile.str()} | docker run --network host -i ` +
-      //     `-e PGPASSWORD=${con.password} ` +
-      //     `postgres:${version} ` +
-      //     `psql ${connectionArgs} -v ON_ERROR_STOP=0`
-      // )
-      // TODO consider pulling the docker images first so the Docke daremon info messages about container pulling are not logged as errors
-
-      return `docker run --rm --network host postgres:${version} ` + `bash -c '${bashCmds.join(' && ')}'`;
-    });
-
     _defineProperty(this, "restore", async ({
       pgUrl,
       pgBinDir
     }) => {
-      // const version = this.getVersion(pgVersion)
-      const storage = this.storageBackendProvider.provide(); // To validate
-
-      const con = parseConnectionUrl(pgUrl);
+      const storage = this.storageBackendProvider.provide();
+      const pg = new _Postgres.Postgres(this.sh, this.fs, {
+        binDir: pgBinDir
+      });
       this.log.info(`Restoring Postgres database`);
-      await this.fs.inTmpDir('pg-restore', async dirStr => {
-        const dir = _Path.AbsPath.from(dirStr);
-
-        storage.restore(dir); // TODO check if the dir contains the with the expected name
+      await this.fs.inTmpDir('pg-restore', async dir => {
+        await storage.restore(dir); // TODO check if the dir contains the with the expected name
         // TODO add e2e test for docker
 
         this.log.info('Backup dir restored');
         const file = PgBackupController.dumpFileName;
-        const zipFile = file + '.gz';
-        const zipPath = this.fs.listFiles(dir).find(n => n.basename() === zipFile);
-        if (!zipPath) throw new Error(`Expected to find file ${zipFile} in the restore data`);
+        const zipFileName = file + '.gz';
+        const zipPath = this.fs.listFiles(dir).find(n => n.basename() === zipFileName);
+        if (!zipPath) throw new Error(`Expected to find file ${zipFileName} in the restore data`);
+        const zipFile = zipPath.str();
         this.log.info(`Decompressing ${zipFile}`);
-        await this.sh.asyncExec(`gzip --decompress -v ${zipFile}`, {
-          cwd: dir.str()
-        }, {
+        await this.sh.asyncExec(`gzip --decompress -v ${zipFile}`, {}, {
           stdout: o => this.log.trace('gzip: ' + o),
           stderr: o => this.log.info('gzip: ' + o)
-        }); // Database is set to 'postgres' so that also users which don't have db created can use db-less URL
-        // Restoring user needs to have the admin access anyway
-
-        const connectionArgs = `-h ${con.host} -p ${con.port} -U ${con.username} -d postgres`; // Don't forget that this itself might be run in docker
-        // therefore volume mounts are not usable (will apply to the location at host)
+        }); // Remove the '.gz' suffix
 
-        let cmd = `psql ${connectionArgs} -v ON_ERROR_STOP=0 < ${file}`;
-
-        if (pgBinDir) {
-          cmd = this.addPgBinDir(cmd, pgBinDir);
-        }
-
-        await this.sh.asyncExec(cmd, {
-          cwd: dir.str(),
-          env: {
-            PGPASSWORD: con.password
-          }
-        }, {
-          stdout: o => this.log.trace(o),
-          stderr: o => this.log.error(o)
-        });
-        this.log.info(`Data successfully inserted into database @${con.host}`);
+        const unzippedFile = zipFile.substring(0, zipFile.length - 3);
+        await pg.restoreAllDbs(_Path.AbsPath.from(unzippedFile), pgUrl);
       });
     });
-
-    _defineProperty(this, "addPgBinDir", (cmd, pgBinDir) => {
-      this.log.info(`Using PG bin dir ${pgBinDir}`);
-      this.fs.ensureIsDir(_Path.AbsPath.from(pgBinDir));
-      return pgBinDir + '/' + cmd;
-    });
   }
 
-}, _defineProperty(_class2, "defaultPgVersion", '14.2'), _defineProperty(_class2, "dumpFileName", 'pg-dump.sql'), _temp)) || _class) || _class) || _class);
+}, _defineProperty(_class2, "dumpFileName", 'pg-dump.sql'), _temp)) || _class) || _class) || _class) || _class);
 exports.PgBackupController = PgBackupController;

package/lib/cli/app.js

@@ -21,6 +21,12 @@ var _DirBackupController = require("../bup/dir/DirBackupController");
 
 var _PgBackupController = require("../bup/pg/PgBackupController");
 
+var _Postgres = require("../tools/pg/Postgres");
+
+var _Shell = require("../tools/shell/Shell");
+
+var _Fs = require("../fs/Fs");
+
 const storageNameOpt = {
   name: 'storage-name',
   convertCase: true,
@@ -45,6 +51,7 @@ const singleStorageOptions = [storageNameOpt, {
 }];
 const backupTagOption = {
   name: 'backup-tag',
+  fromConfig: 'backup.tag',
   convertCase: true
 };
 const backupOptions = [backupTagOption];
@@ -139,38 +146,68 @@ const restic = (0, _nclif.cmdGroup)({
     })
   }
 });
+const pgBinOption = {
+  name: 'pg-bin-dir',
+  description: 'A directory with Postgres binaries (if the ones on the path should not be used)',
+  convertCase: true,
+  fromConfig: 'pg.bin-dir'
+};
 const pg = (0, _nclif.cmdGroup)({
-  description: 'Postgres backup commands',
-  options: [...singleStorageOptions, {
-    name: 'pg-url',
-    description: 'Postgres URL',
-    convertCase: true,
-    fromConfig: 'pg.url',
-    required: true
-  }, {
-    name: 'pg-bin-dir',
-    description: 'A directory with Postgres binaries (if the ones on the path should not be used)',
-    convertCase: true,
-    fromConfig: 'pg.bin-dir'
-  } // {
-  //     name: 'pg-version',
-  //     convertCase: true,
-  //     fromConfig: 'pg.version',
-  //     description: `Postgres version - default is ${PgBackupController.defaultPgVersion}`
-  // }
-  ],
+  options: [pgBinOption],
   commands: {
-    backup: (0, _nclif.cmd)({
-      options: [...backupOptions, {
-        name: 'backup-name',
+    backup: (0, _nclif.cmdGroup)({
+      description: 'Postgres backup commands',
+      options: [...singleStorageOptions, {
+        name: 'pg-url',
+        description: 'Postgres URL',
         convertCase: true,
+        fromConfig: 'pg.url',
         required: true
-      }],
-      run: (inp, c) => c.get(_PgBackupController.PgBackupController).backup(inp)
+      } // {
+      //     name: 'pg-version',
+      //     convertCase: true,
+      //     fromConfig: 'pg.version',
+      //     description: `Postgres version - default is ${PgBackupController.defaultPgVersion}`
+      // }
+      ],
+      commands: {
+        create: (0, _nclif.cmd)({
+          options: [...backupOptions, {
+            name: 'backup-name',
+            convertCase: true,
+            fromConfig: 'backup.name',
+            required: true
+          }],
+          run: (inp, c) => c.get(_PgBackupController.PgBackupController).backup(inp)
+        }),
+        restore: (0, _nclif.cmd)({
+          options: restoreOptions,
+          run: (inp, c) => {
+            try {
+              return c.get(_PgBackupController.PgBackupController).restore(inp);
+            } catch (e) {
+              console.error(e);
+            }
+          }
+        })
+      }
     }),
-    restore: (0, _nclif.cmd)({
-      options: restoreOptions,
-      run: (inp, c) => c.get(_PgBackupController.PgBackupController).restore(inp)
+    copy: (0, _nclif.cmd)({
+      positionals: [{
+        name: 'src-pg-url',
+        description: 'Source Postgres instance',
+        convertCase: true
+      }, {
+        name: 'dst-pg-url',
+        description: 'Target Postgres instance',
+        convertCase: true
+      }],
+      options: [],
+      run: async (inp, c) => {
+        await new _Postgres.Postgres(c.get(_Shell.Shell), c.get(_Fs.Fs), {
+          binDir: inp.pgBinDir
+        }).copyAllDbs(inp.srcPgUrl, inp.dstPgUrl);
+      }
     })
   }
 });

package/lib/fs/Fs.js

@@ -21,6 +21,8 @@ var _logging = require("../log/logging");
 
 var _Path = require("./path/Path");
 
+var _prettyBytes = _interopRequireDefault(require("pretty-bytes"));
+
 var _dec, _dec2, _dec3, _class;
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -47,6 +49,11 @@ let Fs = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:
 
     _defineProperty(this, "isFile", path => !this.isDir(path));
 
+    _defineProperty(this, "getSize", async path => {
+      const res = await _promises.default.stat(path.str());
+      return (0, _prettyBytes.default)(res.size);
+    });
+
     _defineProperty(this, "ensureIsFile", p => {
       if (!this.isFile(p)) throw new Error(`${p} is not a file`);
     });
@@ -69,18 +76,26 @@ let Fs = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:
       return _fs.default.readdirSync(path.str()).map(f => path.resolve(f));
     });
 
-    _defineProperty(this, "inTmpDir", async (name, withDir) => {
-      const dir = this.mkTmpDir(name);
+    _defineProperty(this, "inTmpDir", async (prefix, withDir, opts = {
+      delete: true
+    }) => {
+      let created = false;
+      const dir = this.mkTmpDir(prefix);
+      created = true;
 
       try {
-        await withDir(dir);
+        await withDir(_Path.AbsPath.from(dir));
       } finally {
-        // TODO handle if not exists?
-        this.rmDir(_Path.AbsPath.from(dir));
+        if (created && (opts === null || opts === void 0 ? void 0 : opts.delete) === true) {
+          // TODO handle if not exists?
+          this.rmDir(_Path.AbsPath.from(dir));
+        }
       }
     });
 
-    _defineProperty(this, "inNewDir", async (path, withDir) => {
+    _defineProperty(this, "inNewDir", async (path, withDir, opts = {
+      delete: true
+    }) => {
       let created = false;
 
       try {
@@ -88,7 +103,9 @@ let Fs = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:
         created = true;
         await withDir();
       } finally {
-        if (created) this.rmDir(path);
+        if (created && (opts === null || opts === void 0 ? void 0 : opts.delete) === true) {
+          this.rmDir(path);
+        }
       }
     });
 

package/lib/storage/BackupStorage.js

@@ -12,19 +12,19 @@ class BackupStorage {
     this.backend = backend;
     this.props = props;
 
-    _defineProperty(this, "store", from => {
+    _defineProperty(this, "store", async from => {
       const {
         tag
       } = this.props;
       const tags = tag ? [tag] : undefined;
-      this.backend.backup(from, tags);
+      await this.backend.backup(from, tags);
     });
 
-    _defineProperty(this, "restore", to => {
+    _defineProperty(this, "restore", async to => {
       const {
         snapshotId
       } = this.props;
-      if (snapshotId) this.backend.restoreSnapshot(to, snapshotId);else this.backend.restoreLatest(to);
+      if (snapshotId) await this.backend.restoreSnapshot(to, snapshotId);else await this.backend.restoreLatest(to);
     });
   }
 

package/lib/storage/rclone/RcloneBackupBackend.js

@@ -17,7 +17,7 @@ class RcloneBackupBackend {
 
     _defineProperty(this, "log", (0, _logging.classObjLog)(this));
 
-    _defineProperty(this, "backup", (from, tags) => {
+    _defineProperty(this, "backup", async (from, tags) => {
       if (tags) throw new _nclif.InvalidInputError(`Rclone does not support tags`);
       this.log.info('Performing backup', {
         from
@@ -25,14 +25,14 @@ class RcloneBackupBackend {
       this.rclone.backup(from);
     });
 
-    _defineProperty(this, "restoreLatest", to => {
+    _defineProperty(this, "restoreLatest", async to => {
       this.log.info('Restoring', {
         to
       });
       this.rclone.restore(to);
     });
 
-    _defineProperty(this, "restoreSnapshot", (to, snapshotId) => {
+    _defineProperty(this, "restoreSnapshot", async (to, snapshotId) => {
       throw new _nclif.InvalidInputError(`Rclone does not support snaphosts`);
     });
   }

package/lib/storage/restic/ResticBackupBackend.js

@@ -17,18 +17,18 @@ class ResticBackupBackend {
 
     _defineProperty(this, "log", (0, _logging.classObjLog)(this));
 
-    _defineProperty(this, "backup", (from, tags = []) => {
+    _defineProperty(this, "backup", async (from, tags = []) => {
       this.log.info(`Performing backup from=${from}, tags=${tags}`);
-      this.restic.backup(from, _Path.RelativePath.from('.'), tags);
+      await this.restic.backup(from, _Path.RelativePath.from('.'), tags);
       this.restic.forget();
     });
 
-    _defineProperty(this, "restoreLatest", to => {
+    _defineProperty(this, "restoreLatest", async to => {
       this.log.info(`Restoring latest snapshot to=${to}`);
       this.restic.restore(to);
     });
 
-    _defineProperty(this, "restoreSnapshot", (to, snapshotId) => {
+    _defineProperty(this, "restoreSnapshot", async (to, snapshotId) => {
       this.log.info(`Restoring snapshot '${snapshotId}'`, {
         to
       });

package/lib/storage/restic/ResticClient.js

@@ -46,26 +46,30 @@ class ResticClient {
       });
     });
 
-    _defineProperty(this, "backup", (cwd, from, tags = []) => {
-      this.log.debug('Running backup for repo=%s', this.url);
+    _defineProperty(this, "backup", async (cwd, from, tags = []) => {
+      this.log.debug('Running backup for repo=%s', this.url); // Use -H to set hostname - TODO consider setting explicitly ?
+
       let cmd = `restic backup ${from.str()}`;
       tags.forEach(t => {
         cmd += ` --tag=${t}`;
       });
-      this.shell.exec(cmd, {
+      await this.shell.asyncExec(cmd, {
         cwd: cwd.str(),
         env: this.env()
+      }, {
+        stdout: o => this.log.trace(o),
+        stderr: o => this.log.error(o)
       });
     });
 
-    _defineProperty(this, "restore", (to, snapshotId = 'latest') => {
+    _defineProperty(this, "restore", async (to, snapshotId = 'latest') => {
       this.log.debug('Running restore  for repo=%s', this.url);
       this.shell.exec(`restic restore ${snapshotId} --target ${to.str()}`, {
         env: this.env()
       });
     });
 
-    _defineProperty(this, "forget", () => {
+    _defineProperty(this, "forget", async () => {
       this.log.debug('Pruning repo=%s', this.url);
       const cfg = {
         hourly: 6,

package/lib/storage/restic/ResticClient.spec.js

@@ -32,17 +32,16 @@ describe('ResticClient', () => {
     });
     it('create repo', async () => {
       await sut.prepareRepo();
-      console.log('repo created');
     });
-    it('push data & forget', () => {
+    it('push data & forget', async () => {
       const from = _Path.AbsPath.from(backupDir);
 
       const to = _Path.RelativePath.from('.');
 
-      sut.backup(from, to);
-      sut.backup(from, to, ['foo', 'bar']);
-      sut.forget();
-      sut.backup(from, to);
+      await sut.backup(from, to);
+      await sut.backup(from, to, ['foo', 'bar']);
+      await sut.forget();
+      await sut.backup(from, to);
       const res = sut.snapshots();
       expect(res).toBeArrayOfSize(3);
       const tagged = res[1];
@@ -77,10 +76,10 @@ describe('ResticClient', () => {
     afterAll(() => {
       (0, _testHelper.cleanDir)(restoreDir);
     });
-    it('push and restore data', () => {
+    it('push and restore data', async () => {
       // sut.prepareRepo()
-      sut.backup(_Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'));
-      sut.restore(_Path.AbsPath.from(restoreDir));
+      await sut.backup(_Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'));
+      await sut.restore(_Path.AbsPath.from(restoreDir));
       const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
       expect(res.same).toBeTrue();
     });

package/lib/tools/pg/Postgres.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseConnectionUrl = exports.Postgres = void 0;
+
+var _logging = require("../../log/logging");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class Postgres {
+  constructor(sh, fs, opts) {
+    this.sh = sh;
+    this.fs = fs;
+    this.opts = opts;
+
+    _defineProperty(this, "log", (0, _logging.classObjLog)(this));
+
+    _defineProperty(this, "dumpAllDbs", async (srcPgUrl, dstFilePath) => {
+      const dstFile = dstFilePath.str();
+      this.log.info(`Dumping data into ${dstFile}`);
+      await this.runShellCmd(`${this.dumpAllDbCmd(srcPgUrl)} > ${dstFile}`);
+      const size = await this.fs.getSize(dstFilePath);
+      this.log.trace(`All data dumped into ${dstFile}, size=${size}`);
+    });
+
+    _defineProperty(this, "dumpAllDbCmd", pgUrl => {
+      const con = parseConnectionUrl(pgUrl);
+      const cmd = `PGPASSWORD=${con.password} ${this.bin('pg_dumpall')} -d ${pgUrl} `;
+      return cmd;
+    });
+
+    _defineProperty(this, "restoreAllDbs", async (srcFilePath, dstPgUrl) => {
+      const con = parseConnectionUrl(dstPgUrl);
+      this.log.info(`Restoring data from ${srcFilePath.str()}`);
+      const srcFile = srcFilePath.str();
+      await this.runShellCmd(`${this.restoreAllDbCmd(con)} < ${srcFile}`);
+      this.log.info(`Data successfully inserted into database @${con.host}`);
+    });
+
+    _defineProperty(this, "runShellCmd", async cmd => {
+      await this.sh.asyncExec(cmd, {}, {
+        stdout: o => this.log.trace(o),
+        stderr: o => this.log.error(o)
+      });
+    });
+
+    _defineProperty(this, "restoreAllDbCmd", con => {
+      // Database is set to 'postgres' so that also users which don't have db created can use db-less URL
+      // Restoring user needs to have the admin access anyway - TODO what if default db is not called postgres
+      const database = 'postgres';
+      const connectionArgs = `-h ${con.host} -p ${con.port} -U ${con.username} -d ${database}`;
+      const cmd = ` PGPASSWORD=${con.password} ${this.bin('psql')} ${connectionArgs} -v ON_ERROR_STOP=1`;
+      return cmd;
+    });
+
+    _defineProperty(this, "copyAllDbs", async (srcPgUrl, dstPgUrl) => {
+      await this.runShellCmd(`${this.dumpAllDbCmd(srcPgUrl)} | ${this.restoreAllDbCmd(parseConnectionUrl(dstPgUrl))}`); // Using intermediate file
+      // await this.fs.inTmpDir('foo', async dir => {
+      //     const file = dir.resolve('dump.sql')
+      //     await this.dumpAllDbs(srcPgUrl, file)
+      //     await this.restoreAllDbs(file, dstPgUrl)
+      // })
+    });
+
+    _defineProperty(this, "bin", localBin => {
+      var _this$opts;
+
+      // TODO somehow incorporate this in transparent manner
+      // const version = '16.0'
+      // const dockerWrapper = `docker run --rm --network host postgres:${version} `
+      // TODO figure out how to make transparent execution in Docker image
+      const binDir = (_this$opts = this.opts) === null || _this$opts === void 0 ? void 0 : _this$opts.binDir;
+      if (!binDir) return localBin;
+      return binDir + '/' + localBin;
+    });
+
+    _defineProperty(this, "dumpFromDockerCmd", (pass, pgUrl, version) => {
+      const bashCmds = [`echo "*:*:*:*:${pass}" > ~/.pgpass`, `chmod 400 ~/.pgpass`, `pg_dumpall -d ${pgUrl}`]; // Restore docker command
+      // this.sh.exec(
+      //     `gzip --decompress --stdout ${zipFile.str()} | docker run --network host -i ` +
+      //     `-e PGPASSWORD=${con.password} ` +
+      //     `postgres:${version} ` +
+      //     `psql ${connectionArgs} -v ON_ERROR_STOP=0`
+      // )
+      // TODO consider pulling the docker images first so the Docke daremon info messages about container pulling are not logged as errors
+
+      return `docker run --rm --network host postgres:${version} ` + `bash -c '${bashCmds.join(' && ')}'`;
+    });
+  }
+
+}
+
+exports.Postgres = Postgres;
+
+_defineProperty(Postgres, "defaultPgVersion", '14.2');
+
+const parseConnectionUrl = url => {
+  var _url$match;
+
+  // TODO what if there are query params in the end?
+  const regex = /postgres:\/\/(?<username>.*):(?<password>.*)@(?<host>.*):(?<port>\d*)$/;
+  const match = (_url$match = url.match(regex)) === null || _url$match === void 0 ? void 0 : _url$match.groups;
+  if (!match || !match.username || !match.password || !match.host || !match.port) throw new Error(`The Postgres connection URL does not match required regex: ${regex.toString()}`);
+  return {
+    username: match.username,
+    password: match.password,
+    host: match.host,
+    port: parseInt(match.port, 10),
+    url
+  };
+};
+
+exports.parseConnectionUrl = parseConnectionUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ps-aux/nodebup",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "",
   "module": "lib/index.js",
   "main": "lib/index.js",
@@ -41,6 +41,7 @@
     "@babel/preset-env": "^7.16.7",
     "@babel/preset-typescript": "^7.16.7",
     "@ps-aux/cibs": "^0.6.4",
+    "@testcontainers/postgresql": "^10.7.2",
     "@types/jest": "^27.4.0",
     "@types/jest-when": "^2.7.4",
     "@types/node": "^17.0.6",
@@ -68,9 +69,11 @@
     "npm-check-updates": "^12.0.5",
     "pg": "^8.7.3",
     "prettier": "^2.5.1",
+    "testcontainers": "^10.7.2",
     "ts-jest": "^27.1.2",
     "ts-node": "^10.9.2",
-    "typescript": "^4.5.4"
+    "typescript": "^4.5.4",
+    "vitest": "^1.3.1"
   },
   "lint-staged": {
     "./**/*.{js,ts,tsx}": [
@@ -90,6 +93,7 @@
     "jszip": "^3.10.1",
     "pino": "^7.11.0",
     "pino-pretty": "^9.1.1",
+    "pretty-bytes": "^5.6.0",
     "ramda": "^0.27.1",
     "reflect-metadata": "^0.1.13",
     "unzipper": "^0.10.11",