@ps-aux/nodebup 0.2.0 → 0.2.1

package/lib/bup/AggregateBackupController.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AggregateBackupController = void 0;
+
+var _FsSyncer = require("../fs/fssync/FsSyncer");
+
+var _Config = require("../config/Config");
+
+var _Gpg = require("../tools/gpg/Gpg");
+
+var _Fs = require("../fs/Fs");
+
+var _SshKeyManager = require("../tools/ssh/SshKeyManager");
+
+var _inversify = require("inversify");
+
+var _ContextSymbols = require("../ctx/ContextSymbols");
+
+var _AppLogger = require("../log/AppLogger");
+
+var _StorageBackendProvider = require("../storage/StorageBackendProvider");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+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; }
+
+let AggregateBackupController = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.AppConfig_)(target, undefined, 6);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _Gpg.Gpg === "undefined" ? Object : _Gpg.Gpg, typeof _SshKeyManager.SshKeyManager === "undefined" ? Object : _SshKeyManager.SshKeyManager, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _StorageBackendProvider.StorageBackendProvider === "undefined" ? Object : _StorageBackendProvider.StorageBackendProvider, typeof _Config.Config === "undefined" ? Object : _Config.Config]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class AggregateBackupController {
+  constructor(gpg, ssh, fs, fsSyncer, log, storageBackendProvider, cfg) {
+    this.gpg = gpg;
+    this.ssh = ssh;
+    this.fs = fs;
+    this.fsSyncer = fsSyncer;
+    this.log = log;
+    this.storageBackendProvider = storageBackendProvider;
+    this.cfg = cfg;
+
+    _defineProperty(this, "backup", async (aggregate, storage) => {
+      const aggrDir = this.cfg.pwd.resolve('.aggr');
+      this.fs.ensureDir(aggrDir);
+      const aggr = this.cfg.aggregates.find(a => a.name === aggregate);
+
+      for (const f of aggr.sources.file) {
+        await this.runFileTask(f, aggrDir);
+      }
+
+      this.storageBackendProvider.provide(storage).store(aggrDir);
+      this.fs.rmDir(aggrDir);
+    });
+
+    _defineProperty(this, "runGpgKeyTask", t => {
+      this.log.info('Running GPG key task', t);
+      const key = this.gpg.exportKey(t.id);
+      const to = this.storagePath(t.to || `keys/gpg/${t.id}.asc`);
+      this.fs.writeFile(to, key);
+    });
+
+    _defineProperty(this, "runSshKeyTask", t => {
+      this.log.info('Running SSH key task', t);
+      const key = this.ssh.exportKey(t.id);
+      const to = this.storagePath(t.to || `keys/ssh/${t.id}`);
+      this.fs.writeFile(to, key);
+    });
+
+    _defineProperty(this, "runFileTask", (f, dir) => {
+      this.log.info('Running file task', f);
+      const {
+        from,
+        to
+      } = f;
+      this.fsSyncer.sync(from, dir.resolve(to));
+    });
+
+    _defineProperty(this, "storagePath", path => {
+      throw new Error('Unspported');
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.AggregateBackupController = AggregateBackupController;

package/lib/cli/app.js

@@ -13,17 +13,42 @@ var _Config = require("../config/Config");
 
 var _Context = require("../ctx/Context");
 
-var _TaskRunner = require("../bup/TaskRunner");
+var _AggregateBackupController = require("../bup/AggregateBackupController");
+
+var _ResticController = require("../storage/restic/ResticController");
 
 const createApp = () => _nclif.CliApp.of({
-  options: [],
   commands: {
-    go: (0, _nclif.cmd)({
-      description: 'Run backup',
-      run: (_, ctx) => ctx.get(_TaskRunner.TaskRunner).runAll()
+    restic: (0, _nclif.cmdGroup)({
+      commands: {
+        'init-repo': (0, _nclif.cmd)({
+          positionals: [{
+            name: 'resticStorageName',
+            required: true
+          }],
+          run: (arg, c) => c.get(_ResticController.ResticController).initRepo(arg.resticStorageName)
+        })
+      }
+    }),
+    aggr: (0, _nclif.cmdGroup)({
+      commands: {
+        backup: (0, _nclif.cmd)({
+          description: 'Run backup',
+          positionals: [{
+            name: 'aggregateName',
+            type: 'string',
+            required: true
+          }, {
+            name: 'storageName',
+            type: 'string',
+            required: true
+          }],
+          run: (a, c) => c.get(_AggregateBackupController.AggregateBackupController).backup(a.aggregateName, a.storageName)
+        })
+      }
     })
   }
-}).addObjectConfig(pwd => (0, _Config.readConfig)(pwd + '/bup.yaml')).context(({
+}).addObjectConfig(pwd => (0, _Config.readConfig)(pwd)).context(({
   config
 }) => (0, _Context.createContext)(config));
 

package/lib/config/Config.js

@@ -11,31 +11,48 @@ var _readYaml = require("../fs/readYaml");
 
 var _validateConfigAgainstSchema = require("./validateConfigAgainstSchema");
 
-var _expandPath = require("./expandPath");
+var _expandAndCreatePath = require("./expandAndCreatePath");
 
-const readConfig = path => {
-  const file = _Path.AbsPath.from(path);
+const expandPaths = (cfg, exp, cwd) => {
+  cfg.storage.filter(s => s.type === 'file').map(s => s).forEach(s => {
+    s.path = exp(s.path);
+  });
+  cfg.storage.filter(s => s.type === 'restic').map(s => s).forEach(s => {
+    if (s.credentialsFile) s.credentialsFile = exp(s.credentialsFile);
+    s.passwordFile = exp(s.passwordFile);
+    if (s.repo.startsWith('local:')) s.repo = (0, _expandAndCreatePath.expandStrPath)(s.repo, cwd);
+  });
+  cfg.aggregates.forEach(a => {
+    a.sources.file.forEach(f => {
+      f.from = exp(f.from);
+      f.to = _Path.RelativePath.from(f.to);
+    });
+  });
+};
 
-  const obj = (0, _readYaml.readYaml)(file.str());
-  (0, _validateConfigAgainstSchema.validateConfigAgainstSchema)(obj);
-  const rootDir = file.parent();
+const readConfig = pwdStr => {
+  const cwd = _Path.AbsPath.from(pwdStr);
+
+  const cfgFile = (0, _readYaml.readYaml)(cwd.resolve('bup.yaml').str());
+  (0, _validateConfigAgainstSchema.validateConfigAgainstSchema)(cfgFile);
+  const cfg = cfgFile;
+  cfg.pwd = cwd;
+  cfg.aggregates.forEach(t => {
+    const {
+      sources
+    } = t;
+    sources.file = sources.file ?? [];
+    sources.sshKey = sources.sshKey ?? [];
+    sources.gpgKey = sources.gpgKey ?? [];
+  });
 
   const expand = str => {
-    const p = (0, _expandPath.expandPath)(str, rootDir);
+    const p = (0, _expandAndCreatePath.expandAndCreatePath)(str, cwd);
     return p;
   };
 
-  if (!obj.tasks.file) obj.tasks.file = [];
-  if (!obj.tasks.gpgKey) obj.tasks.gpgKey = [];
-  if (!obj.tasks.sshKey) obj.tasks.sshKey = [];
-  obj.tasks.file.forEach(t => {
-    t.from = expand(t.from);
-    t.to = _Path.RelativePath.from(t.to);
-  });
-  obj.storage.forEach(s => {
-    s.path = expand(s.path);
-  });
-  return obj;
+  expandPaths(cfg, expand, cwd);
+  return cfg;
 };
 
 exports.readConfig = readConfig;

package/lib/config/expandAndCreatePath.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.expandStrPath = exports.expandAndCreatePath = void 0;
+
+var _Path = require("../fs/path/Path");
+
+var _os = _interopRequireDefault(require("os"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const expandStrPath = (path, pwd) => {
+  path = path.replace('<cwd>', pwd.str());
+  path = path.replace('~', _os.default.homedir());
+  return path;
+};
+
+exports.expandStrPath = expandStrPath;
+
+const expandAndCreatePath = (path, pwd) => _Path.AbsPath.from(expandStrPath(path, pwd));
+
+exports.expandAndCreatePath = expandAndCreatePath;

package/lib/config/validateConfigAgainstSchema.js

@@ -21,18 +21,37 @@ const KeyTaskSchema = _joi.default.object({
   to: _joi.default.string().optional()
 });
 
-const StorageSchema = _joi.default.object({
+const createStorageSchema = props => _joi.default.object({
+  name: _joi.default.string(),
+  type: _joi.default.string(),
+  ...props
+});
+
+const FileStorageSchema = createStorageSchema({
   path: _joi.default.string()
 });
+const ResticStorageSchema = createStorageSchema({
+  repo: _joi.default.string(),
+  credentialsFile: _joi.default.string().optional(),
+  passwordFile: _joi.default.string()
+});
+
+const Sources = _joi.default.object({
+  dir: _joi.default.array().items(DirTaskSchema).optional(),
+  file: _joi.default.array().items(FileTaskSchema).optional(),
+  gpgKey: _joi.default.array().items(KeyTaskSchema).optional(),
+  sshKey: _joi.default.array().items(KeyTaskSchema).optional()
+});
+
+const Aggregate = _joi.default.object({
+  name: _joi.default.string(),
+  sources: Sources
+});
 
 const Schema = () => _joi.default.object({
-  storage: _joi.default.array().items(StorageSchema),
-  tasks: _joi.default.object({
-    dir: _joi.default.array().items(DirTaskSchema).optional(),
-    file: _joi.default.array().items(FileTaskSchema).optional(),
-    gpgKey: _joi.default.array().items(KeyTaskSchema).optional(),
-    sshKey: _joi.default.array().items(KeyTaskSchema).optional()
-  })
+  // TODO undescriptive error msg. Invalid config."storage[0]" does not match any of the allowed types
+  storage: _joi.default.array().items(FileStorageSchema, ResticStorageSchema),
+  aggregates: _joi.default.array().items(Aggregate)
 });
 
 const validateConfigAgainstSchema = cfg => {

package/lib/config/validateConfigAgainstSchema.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _validateConfigAgainstSchema = require("./validateConfigAgainstSchema");
+
+const f1 = {
+  storage: [{
+    name: 'fs',
+    type: 'file',
+    path: '~/tmp/nodepub/test-store'
+  }, {
+    name: 'restic',
+    type: 'restic',
+    repo: 'b2:reo',
+    credentialsFile: '.b2-credentials.json',
+    passwordFile: 'pass-file'
+  }],
+  aggregates: [{
+    name: 'my-task',
+    sources: {
+      file: [{
+        from: 'foo',
+        to: 'foo'
+      }]
+    }
+  }]
+};
+it('validate', () => {
+  (0, _validateConfigAgainstSchema.validateConfigAgainstSchema)(f1);
+});

package/lib/ctx/Context.js

@@ -17,23 +17,25 @@ var _SshKeyManager = require("../tools/ssh/SshKeyManager");
 
 var _inversify = require("inversify");
 
-var _PlainCopyDataStorage = require("../storage/PlainCopyDataStorage");
-
 var _ContextSymbols = require("./ContextSymbols");
 
-var _TaskRunner = require("../bup/TaskRunner");
+var _AggregateBackupController = require("../bup/AggregateBackupController");
 
 var _AppLogger = require("../log/AppLogger");
 
+var _StorageBackendProvider = require("../storage/StorageBackendProvider");
+
+var _ResticClientFactory = require("../storage/restic/ResticClientFactory");
+
+var _ResticController = require("../storage/restic/ResticController");
+
 const createContext = cfg => {
-  if (cfg.storage.length !== 1) throw new Error('Exactly one storage path is required');
   const c = new _inversify.Container();
-  c.bind(_ContextSymbols.TaskConfig_).toConstantValue(cfg.tasks);
-  c.bind(_ContextSymbols.StorageConfig_).toConstantValue(cfg.storage[0]);
+  c.bind(_ContextSymbols.AppConfig_).toConstantValue(cfg);
   const log = new _AppLogger.AppLogger();
   c.bind(_ContextSymbols.Log_).toConstantValue(log);
   c.bind(_AppLogger.AppLogger).toConstantValue(log);
-  const self = [_Gpg.Gpg, _Shell.Shell, _Fs.Fs, _FsSyncer.FsSyncer, _SshKeyManager.SshKeyManager, _PlainCopyDataStorage.PlainCopyDataStorage, _TaskRunner.TaskRunner];
+  const self = [_Gpg.Gpg, _Shell.Shell, _Fs.Fs, _FsSyncer.FsSyncer, _SshKeyManager.SshKeyManager, _StorageBackendProvider.StorageBackendProvider, _ResticClientFactory.ResticClientFactory, _AggregateBackupController.AggregateBackupController, _ResticController.ResticController];
   self.forEach(s => c.bind(s).toSelf());
   return c;
 };

package/lib/ctx/ContextSymbols.js

@@ -3,10 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TaskConfig_ = exports.StorageConfig_ = exports.Log_ = void 0;
+exports.TaskConfig_ = exports.StorageConfig_ = exports.Log_ = exports.AppConfig_ = void 0;
 const Log_ = Symbol.for('Log');
 exports.Log_ = Log_;
 const TaskConfig_ = Symbol.for('config.Tasks');
 exports.TaskConfig_ = TaskConfig_;
 const StorageConfig_ = Symbol.for('config.Storage');
-exports.StorageConfig_ = StorageConfig_;
+exports.StorageConfig_ = StorageConfig_;
+const AppConfig_ = Symbol.for('config.app');
+exports.AppConfig_ = AppConfig_;

package/lib/fs/Fs.js

@@ -28,13 +28,34 @@ let Fs = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:
       _fs.default.writeFileSync(path.str(), content);
     });
 
-    _defineProperty(this, "isFile", path => !_fs.default.lstatSync(path.str()).isDirectory());
+    _defineProperty(this, "isFile", path => !this.isDir(path));
+
+    _defineProperty(this, "ensureIsFile", p => {
+      if (!this.isFile(p)) throw new Error(`${p} is not a file`);
+    });
+
+    _defineProperty(this, "isDir", path => _fs.default.lstatSync(path.str()).isDirectory());
+
+    _defineProperty(this, "rmDir", path => {
+      _fs.default.rmdirSync(path.str(), {
+        recursive: true
+      });
+    });
+
+    _defineProperty(this, "ensureIsDir", p => {
+      if (!this.isDir(p)) throw new Error(`${p} is not a dir`);
+    });
 
     _defineProperty(this, "readFile", path => {
-      this.log.debug('Reading from file', path.str);
+      this.log.debug('Reading from file', path.str());
       return _fs.default.readFileSync(path.str()).toString();
     });
 
+    _defineProperty(this, "readJson", path => {
+      const file = this.readFile(path);
+      return JSON.parse(file);
+    });
+
     _defineProperty(this, "ensureDir", path => {
       if (!this.exists(path)) {
         this.log.debug('Dir ', path, 'does not exist. Wil be created');

package/lib/fs/fssync/FsSyncer.js

@@ -29,15 +29,21 @@ let FsSyncer = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("d
     this.fs = fs;
     this.log = log;
 
+    _defineProperty(this, "sync", (from, to) => {
+      if (this.fs.isFile(from)) this.syncFile(from, to);else this.syncDirs(from, to);
+    });
+
     _defineProperty(this, "syncDirs", (from, to) => {
+      this.fs.ensureIsDir(from);
       this.log.info('Syncing dir', from.str(), '==>', to.str());
       const fromPath = toUnixDirString(from);
       const toPath = toUnixDirString(to);
       this.fs.ensureParentDir(to);
-      this.sh.exec(`rsync -rtv ${fromPath} ${toPath}`);
+      this.sh.exec(`rsync -rtv --delete ${fromPath} ${toPath}`);
     });
 
     _defineProperty(this, "syncFile", (from, to) => {
+      this.fs.ensureIsFile(from);
       this.log.info('Syncing file', from.str(), '==>', to.str());
       this.fs.ensureParentDir(to);
       this.sh.exec(`rsync -rtv ${from.str()} ${to.str()}`);

package/lib/storage/StorageBackendProvider.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StorageBackendProvider = void 0;
+
+var _inversify = require("inversify");
+
+var _FsSyncer = require("../fs/fssync/FsSyncer");
+
+var _LocalFileStorageBackend = require("./local-file/LocalFileStorageBackend");
+
+var _ContextSymbols = require("../ctx/ContextSymbols");
+
+var _Config = require("../config/Config");
+
+var _ResticClientFactory = require("./restic/ResticClientFactory");
+
+var _ResticStorageBackend = require("./restic/ResticStorageBackend");
+
+var _Fs = require("../fs/Fs");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+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; }
+
+let StorageBackendProvider = (_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 _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _ResticClientFactory.ResticClientFactory === "undefined" ? Object : _ResticClientFactory.ResticClientFactory, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _Config.Config === "undefined" ? Object : _Config.Config]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class StorageBackendProvider {
+  constructor(fsSyncer, resticFac, fs, cfg) {
+    this.fsSyncer = fsSyncer;
+    this.resticFac = resticFac;
+    this.fs = fs;
+    this.cfg = cfg;
+
+    _defineProperty(this, "provide", name => {
+      const s = this.cfg.storage.find(s => s.name === name);
+      if (!s) throw new Error(`No such storage '${name}'`);
+      if (s.type === 'restic') return this.restic(s);else if (s.type === 'file') return this.localFile(s);else throw new Error(`Unsupported storage type ${s.type}`);
+    });
+
+    _defineProperty(this, "restic", cfg => {
+      return new _ResticStorageBackend.ResticStorageBackend(this.resticFac.create(cfg));
+    });
+
+    _defineProperty(this, "localFile", cfg => {
+      return new _LocalFileStorageBackend.LocalFileStorageBackend(this.fsSyncer, cfg.path);
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.StorageBackendProvider = StorageBackendProvider;

package/lib/storage/local-file/LocalFileStorageBackend.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalFileStorageBackend = void 0;
+
+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 LocalFileStorageBackend {
+  constructor(fsSyncer, dst) {
+    this.fsSyncer = fsSyncer;
+    this.dst = dst;
+
+    _defineProperty(this, "store", from => {
+      this.fsSyncer.syncDirs(from, this.dst);
+    });
+  }
+
+}
+
+exports.LocalFileStorageBackend = LocalFileStorageBackend;

package/lib/storage/restic/ResticClient.js

@@ -25,45 +25,61 @@ const normalizeUrl = url => {
   return url;
 };
 /**
+ * Tested with: restic 0.9.6 compiled with go1.12.12 on linux/amd64
  * TODO forwarding stdout to the logger
  */
 
 
 let ResticClient = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
-  return (0, _inversify.inject)(_ContextSymbols.TaskConfig_)(target, undefined, 1);
-}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _types.Log === "undefined" ? Object : _types.Log]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class ResticClient {
-  constructor(shell, log) {
+  return (0, _inversify.inject)(_ContextSymbols.TaskConfig_)(target, undefined, 2);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof ResticConfig === "undefined" ? Object : ResticConfig, typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _types.Log === "undefined" ? Object : _types.Log]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class ResticClient {
+  constructor(cfg, shell, log) {
+    this.cfg = cfg;
     this.shell = shell;
     this.log = log;
 
-    _defineProperty(this, "prepareRepo", (url, password) => {
-      url = normalizeUrl(url);
-      this.log.info('Preparing a restic repo', url);
-      this.shell.exec(`restic init --repo ${url}`, {
-        env: {
-          RESTIC_PASSWORD: password
-        }
+    _defineProperty(this, "url", void 0);
+
+    _defineProperty(this, "prepareRepo", () => {
+      this.log.info(`Preparing a restic repo at '${this.url}`);
+      this.shell.exec(`restic init`, {
+        env: this.env()
       });
     });
 
-    _defineProperty(this, "backup", (url, cwd, from, password) => {
-      url = normalizeUrl(url);
-      this.shell.exec(`restic --repo ${url} backup ${from.str()}`, {
+    _defineProperty(this, "backup", (cwd, from) => {
+      this.shell.exec(`restic backup ${from.str()}`, {
         cwd: cwd.str(),
-        env: {
-          RESTIC_PASSWORD: password
-        }
+        env: this.env()
       });
     });
 
-    _defineProperty(this, "restore", (url, to, password) => {
-      url = normalizeUrl(url);
-      this.shell.exec(`restic --repo ${url} restore latest --target ${to.str()}`, {
-        env: {
-          RESTIC_PASSWORD: password
-        }
+    _defineProperty(this, "restore", to => {
+      this.shell.exec(`restic restore latest --target ${to.str()}`, {
+        env: this.env()
       });
     });
+
+    _defineProperty(this, "env", () => ({
+      RESTIC_PASSWORD: this.cfg.repo.password,
+      RESTIC_REPOSITORY: this.url,
+      ...this.getCredentialsForUrl(this.url)
+    }));
+
+    _defineProperty(this, "getCredentialsForUrl", url => {
+      if (url.startsWith('b2:')) {
+        const cfg = this.cfg.backblaze;
+        if (!cfg) throw new Error(`Repo url ${url} refers to Backblaze but no Backblaze config provided`);
+        return {
+          B2_ACCOUNT_ID: cfg.accountId,
+          B2_ACCOUNT_KEY: cfg.accountKey
+        };
+      }
+
+      return {};
+    });
+
+    this.url = normalizeUrl(cfg.repo.url);
   }
 
 }) || _class) || _class) || _class) || _class);

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

@@ -10,41 +10,87 @@ var _test = require("../../../test");
 
 var _fs = _interopRequireDefault(require("fs"));
 
+var _path = _interopRequireDefault(require("path"));
+
 var _Path = require("../../fs/path/Path");
 
 var _dirCompare = require("dir-compare");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-/*
- * Tested with: restic 0.9.6 compiled with go1.12.12 on linux/amd64
- */
-describe.skip('ResticClient', () => {
+const getBackblazeConfig = () => {
+  const path = _path.default.resolve(__dirname, '../../../.keys.json');
+
+  if (!_fs.default.existsSync(path)) return undefined;
+  const data = JSON.parse(_fs.default.readFileSync(path).toString());
+  return {
+    accountId: data.restic.backblaze.keyID,
+    accountKey: data.restic.backblaze.applicationKey
+  };
+};
+
+describe('ResticClient', () => {
   const l = new _AppLogger.AppLogger();
-  const sut = new _ResticClient.ResticClient(new _Shell.Shell(l), l);
   const password = 'foo123';
-  const repoDir = (0, _test.testdataDir)('my-repo');
   const backupDir = (0, _test.testDir)('backup-me');
-  const restoreDir = (0, _test.testdataDir)('restore');
-  const repoUrl = `local:${repoDir}`;
-  afterAll(() => {
-    _fs.default.rmdirSync(repoDir, {
-      recursive: true
-    });
+  describe('local', () => {
+    const repoDir = (0, _test.testdataDir)('my-repo');
+    const restoreDir = (0, _test.testdataDir)('restore/local');
+    const sut = new _ResticClient.ResticClient({
+      repo: {
+        password,
+        url: `local:${repoDir}`
+      }
+    }, new _Shell.Shell(l), l);
+    afterAll(() => {
+      _fs.default.rmdirSync(repoDir, {
+        recursive: true
+      });
 
-    _fs.default.rmdirSync(restoreDir, {
-      recursive: true
+      _fs.default.rmdirSync(restoreDir, {
+        recursive: true
+      });
+    });
+    it('create repo', () => {
+      sut.prepareRepo();
+    });
+    it('push data', () => {
+      sut.backup(_Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'));
+    });
+    it('restore data', () => {
+      sut.restore(_Path.AbsPath.from(restoreDir));
+      const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
+      expect(res.same).toBeTrue();
     });
   });
-  it('create repo', () => {
-    sut.prepareRepo(repoUrl, password);
-  });
-  it('push data', () => {
-    sut.backup(repoUrl, _Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'), password);
-  });
-  it('restore data', () => {
-    sut.restore(repoUrl, _Path.AbsPath.from(restoreDir), password);
-    const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
-    expect(res.same).toBeTrue();
+  describe('b2', () => {
+    const b2Cfg = getBackblazeConfig();
+
+    if (!b2Cfg) {
+      console.log('No B2 config - skipping');
+      return;
+    }
+
+    const restoreDir = (0, _test.testdataDir)('restore/b2');
+    const repoUrl = `b2:psaux-nodepub-test`;
+    const sut = new _ResticClient.ResticClient({
+      repo: {
+        password,
+        url: repoUrl
+      },
+      backblaze: b2Cfg
+    }, new _Shell.Shell(l), l);
+    afterAll(() => {
+      _fs.default.rmdirSync(restoreDir, {
+        recursive: true
+      });
+    });
+    it('push adn restore data', () => {
+      //     sut.prepareRepo(repoUrl, password)
+      sut.backup(_Path.AbsPath.from(backupDir), _Path.RelativePath.from('.'));
+      sut.restore(_Path.AbsPath.from(restoreDir));
+      const res = (0, _dirCompare.compareSync)(backupDir, restoreDir);
+      expect(res.same).toBeTrue();
+    });
   });
 });

package/lib/storage/restic/ResticClientFactory.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticClientFactory = void 0;
+
+var _inversify = require("inversify");
+
+var _ResticClient = require("./ResticClient");
+
+var _Shell = require("../../tools/shell/Shell");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _Fs = require("../../fs/Fs");
+
+var _joi = _interopRequireDefault(require("@hapi/joi"));
+
+var _dec, _dec2, _dec3, _class;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 CredentialsFileSchema = _joi.default.object({
+  keyID: _joi.default.string(),
+  keyName: _joi.default.string().optional(),
+  applicationKey: _joi.default.string()
+});
+
+const validateCredentials = obj => {
+  const r = CredentialsFileSchema.validate(obj, {
+    presence: 'required',
+    allowUnknown: false
+  });
+  return r.error ? JSON.stringify(r.error) : null;
+};
+
+let ResticClientFactory = (_dec = (0, _inversify.injectable)(), _dec2 = Reflect.metadata("design:type", Function), _dec3 = Reflect.metadata("design:paramtypes", [typeof _Shell.Shell === "undefined" ? Object : _Shell.Shell, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs]), _dec(_class = _dec2(_class = _dec3(_class = class ResticClientFactory {
+  constructor(sh, log, fs) {
+    this.sh = sh;
+    this.log = log;
+    this.fs = fs;
+
+    _defineProperty(this, "create", cfg => {
+      const password = this.fs.readFile(cfg.passwordFile).trim();
+      const props = {
+        repo: {
+          password,
+          url: cfg.repo
+        }
+      };
+
+      if (cfg.credentialsFile) {
+        if (!cfg.repo.startsWith('b2:')) throw new Error('Credentials can be supported only for the B2 restic backend');
+        const credJson = this.fs.readJson(cfg.credentialsFile); //
+
+        const validationErr = validateCredentials(credJson);
+
+        if (validationErr) {
+          throw new Error(`Invalid Restic credential in ${cfg.credentialsFile}: ${validationErr}`);
+        }
+
+        const creds = credJson;
+        props.backblaze = {
+          accountId: creds.keyID,
+          accountKey: creds.applicationKey
+        };
+      }
+
+      return new _ResticClient.ResticClient(props, this.sh, this.log);
+    });
+  }
+
+}) || _class) || _class) || _class);
+exports.ResticClientFactory = ResticClientFactory;

package/lib/storage/restic/ResticController.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticController = void 0;
+
+var _inversify = require("inversify");
+
+var _ContextSymbols = require("../../ctx/ContextSymbols");
+
+var _Config = require("../../config/Config");
+
+var _ResticClientFactory = require("./ResticClientFactory");
+
+var _AppLogger = require("../../log/AppLogger");
+
+var _dec, _dec2, _dec3, _dec4, _class;
+
+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; }
+
+let ResticController = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
+  return (0, _inversify.inject)(_ContextSymbols.AppConfig_)(target, undefined, 2);
+}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _ResticClientFactory.ResticClientFactory === "undefined" ? Object : _ResticClientFactory.ResticClientFactory, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _Config.Config === "undefined" ? Object : _Config.Config]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class ResticController {
+  constructor(restFact, log, cfg) {
+    this.restFact = restFact;
+    this.log = log;
+    this.cfg = cfg;
+
+    _defineProperty(this, "initRepo", storageName => {
+      const s = this.cfg.storage.filter(s => s.type === 'restic').find(s => s.name === storageName);
+      if (!s) throw new Error(`No restic storage '${storageName}'`);
+      this.log.info('Initializing repo', storageName);
+      this.restFact.create(s).prepareRepo();
+    });
+  }
+
+}) || _class) || _class) || _class) || _class);
+exports.ResticController = ResticController;

package/lib/storage/restic/ResticStorageBackend.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResticStorageBackend = void 0;
+
+var _Path = require("../../fs/path/Path");
+
+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 ResticStorageBackend {
+  constructor(client) {
+    this.client = client;
+
+    _defineProperty(this, "store", from => {
+      this.client.backup(from, _Path.RelativePath.from('.'));
+    });
+  }
+
+}
+
+exports.ResticStorageBackend = ResticStorageBackend;

package/lib/tools/gpg/Gpg.spec.js

@@ -6,9 +6,9 @@ var _Gpg = require("./Gpg");
 
 var _Shell = require("../shell/Shell");
 
-// TODO setup ci to make tests work
+// TODO find a way hot to provide prompt via stdin
 it.skip('works', () => {
   const sut = new _Gpg.Gpg(new _Shell.Shell(new _AppLogger.AppLogger()));
-  const key = sut.exportKey('foo');
+  const key = sut.exportKey('john.doe@foo.com');
   console.log('key', key);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ps-aux/nodebup",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "",
   "module": "lib/index.js",
   "main": "lib/index.js",

package/lib/bup/TaskRunner.js

@@ -1,82 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.TaskRunner = void 0;
-
-var _FsSyncer = require("../fs/fssync/FsSyncer");
-
-var _Config = require("../config/Config");
-
-var _Gpg = require("../tools/gpg/Gpg");
-
-var _Fs = require("../fs/Fs");
-
-var _SshKeyManager = require("../tools/ssh/SshKeyManager");
-
-var _inversify = require("inversify");
-
-var _ContextSymbols = require("../ctx/ContextSymbols");
-
-var _PlainCopyDataStorage = require("../storage/PlainCopyDataStorage");
-
-var _AppLogger = require("../log/AppLogger");
-
-var _dec, _dec2, _dec3, _dec4, _class;
-
-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; }
-
-let TaskRunner = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
-  return (0, _inversify.inject)(_ContextSymbols.TaskConfig_)(target, undefined, 6);
-}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _Gpg.Gpg === "undefined" ? Object : _Gpg.Gpg, typeof _SshKeyManager.SshKeyManager === "undefined" ? Object : _SshKeyManager.SshKeyManager, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _PlainCopyDataStorage.PlainCopyDataStorage === "undefined" ? Object : _PlainCopyDataStorage.PlainCopyDataStorage, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger, typeof _Config.Tasks === "undefined" ? Object : _Config.Tasks]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class TaskRunner {
-  constructor(sync, gpg, ssh, fs, storage, log, tasks) {
-    this.sync = sync;
-    this.gpg = gpg;
-    this.ssh = ssh;
-    this.fs = fs;
-    this.storage = storage;
-    this.log = log;
-    this.tasks = tasks;
-
-    _defineProperty(this, "runAll", async () => {
-      const tasks = this.tasks;
-
-      if (tasks.file.length > 0) {
-        for (const t of tasks.file) {
-          await this.runFileTask(t);
-        }
-      }
-
-      return; // eslint-disable-next-line no-unreachable
-
-      if (tasks.gpgKey.length > 0) tasks.gpgKey.forEach(this.runGpgKeyTask);
-      if (tasks.sshKey.length > 0) tasks.sshKey.forEach(this.runSshKeyTask);
-    });
-
-    _defineProperty(this, "runGpgKeyTask", t => {
-      this.log.info('Running GPG key task', t);
-      const key = this.gpg.exportKey(t.id);
-      const to = this.storagePath(t.to || `keys/gpg/${t.id}.asc`);
-      this.fs.writeFile(to, key);
-    });
-
-    _defineProperty(this, "runSshKeyTask", t => {
-      this.log.info('Running SSH key task', t);
-      const key = this.ssh.exportKey(t.id);
-      const to = this.storagePath(t.to || `keys/ssh/${t.id}`);
-      this.fs.writeFile(to, key);
-    });
-
-    _defineProperty(this, "runFileTask", async t => {
-      this.log.info('Running file task', t);
-      this.storage.store(t.from, t.to);
-    });
-
-    _defineProperty(this, "storagePath", path => {
-      throw new Error('Unspported');
-    });
-  }
-
-}) || _class) || _class) || _class) || _class);
-exports.TaskRunner = TaskRunner;

package/lib/config/expandPath.js

@@ -1,20 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.expandPath = void 0;
-
-var _Path = require("../fs/path/Path");
-
-var _os = _interopRequireDefault(require("os"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const expandPath = (path, rootDir) => {
-  path = path.replace('<cwd>', rootDir.str);
-  path = path.replace('~', _os.default.homedir());
-  return _Path.AbsPath.from(path);
-};
-
-exports.expandPath = expandPath;

package/lib/storage/PlainCopyDataStorage.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PlainCopyDataStorage = void 0;
-
-var _inversify = require("inversify");
-
-var _FsSyncer = require("../fs/fssync/FsSyncer");
-
-var _Config = require("../config/Config");
-
-var _ContextSymbols = require("../ctx/ContextSymbols");
-
-var _Fs = require("../fs/Fs");
-
-var _AppLogger = require("../log/AppLogger");
-
-var _dec, _dec2, _dec3, _dec4, _class;
-
-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; }
-
-let PlainCopyDataStorage = (_dec = (0, _inversify.injectable)(), _dec2 = function (target, key) {
-  return (0, _inversify.inject)(_ContextSymbols.StorageConfig_)(target, undefined, 1);
-}, _dec3 = Reflect.metadata("design:type", Function), _dec4 = Reflect.metadata("design:paramtypes", [typeof _FsSyncer.FsSyncer === "undefined" ? Object : _FsSyncer.FsSyncer, typeof _Config.StorageInstance === "undefined" ? Object : _Config.StorageInstance, typeof _Fs.Fs === "undefined" ? Object : _Fs.Fs, typeof _AppLogger.AppLogger === "undefined" ? Object : _AppLogger.AppLogger]), _dec(_class = _dec2(_class = _dec3(_class = _dec4(_class = class PlainCopyDataStorage {
-  constructor(fsSyncer, storage, fs, log) {
-    this.fsSyncer = fsSyncer;
-    this.storage = storage;
-    this.fs = fs;
-    this.log = log;
-
-    _defineProperty(this, "store", async (from, to) => {
-      this.log.info(`Storing ${from} to ${to}`);
-      if (this.fs.isFile(from)) this.fsSyncer.syncFile(from, this.storage.path.resolve(to));else this.fsSyncer.syncDirs(from, this.storage.path.resolve(to));
-    });
-  }
-
-}) || _class) || _class) || _class) || _class);
-exports.PlainCopyDataStorage = PlainCopyDataStorage;