@xen-orchestra/fs 3.1.0 → 3.3.0

package/dist/abstract.js

@@ -4,121 +4,93 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _legacy = _interopRequireDefault(require("@xen-orchestra/async-map/legacy"));
-
 var _assert = _interopRequireDefault(require("assert"));
-
 var _getStream = _interopRequireDefault(require("get-stream"));
-
 var _coalesceCalls = require("@vates/coalesce-calls");
-
 var _log = require("@xen-orchestra/log");
-
 var _promiseToolbox = require("promise-toolbox");
-
 var _limitConcurrencyDecorator = require("limit-concurrency-decorator");
-
 var _xoRemoteParser = require("xo-remote-parser");
-
 var _stream = require("stream");
-
 var _crypto = require("crypto");
-
 var _decoratorSynchronized = require("decorator-synchronized");
-
 var _path = require("./path");
-
 var _checksum = require("./checksum");
-
 var _encryptor = require("./_encryptor");
-
 var _dec, _dec2, _class;
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
-
 const {
   info,
   warn
 } = (0, _log.createLogger)('@xen-orchestra:fs');
-
 const checksumFile = file => file + '.checksum';
-
 const computeRate = (hrtime, size) => {
   const seconds = hrtime[0] + hrtime[1] / 1e9;
   return size / seconds;
 };
-
 const DEFAULT_TIMEOUT = 6e5;
 const DEFAULT_MAX_PARALLEL_OPERATIONS = 10;
 const ENCRYPTION_DESC_FILENAME = 'encryption.json';
 const ENCRYPTION_METADATA_FILENAME = 'metadata.json';
-
 const ignoreEnoent = error => {
   if (error == null || error.code !== 'ENOENT') {
     throw error;
   }
 };
-
 const noop = Function.prototype;
-
 class PrefixWrapper {
   constructor(handler, prefix) {
     this._prefix = prefix;
     this._handler = handler;
   }
-
   get type() {
     return this._handler.type;
   }
 
   async list(dir, opts) {
     const entries = await this._handler.list(this._resolve(dir), opts);
-
     if (opts != null && opts.prependDir) {
       const n = this._prefix.length;
       entries.forEach((entry, i, entries) => {
         entries[i] = entry.slice(n);
       });
     }
-
     return entries;
   }
-
   rename(oldPath, newPath) {
     return this._handler.rename(this._resolve(oldPath), this._resolve(newPath));
   }
-
   _resolve(path) {
     return this._prefix + (0, _path.normalize)(path);
   }
-
 }
-
 let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(), _dec2 = (0, _decoratorSynchronized.synchronized)(), (_class = class RemoteHandlerAbstract {
-  _encryptor;
-
+  #encryptor;
+  get _encryptor() {
+    if (this.#encryptor === undefined) {
+      throw new Error(`Can't access to encryptor before remote synchronization`);
+    }
+    return this.#encryptor;
+  }
   constructor(remote, options = {}) {
     if (remote.url === 'test://') {
       this._remote = remote;
     } else {
-      this._remote = { ...remote,
+      this._remote = {
+        ...remote,
         ...(0, _xoRemoteParser.parse)(remote.url)
       };
-
       if (this._remote.type !== this.type) {
         throw new Error('Incorrect remote type');
       }
     }
-
     ;
     ({
       highWaterMark: this._highWaterMark,
       timeout: this._timeout = DEFAULT_TIMEOUT
     } = options);
-    this._encryptor = (0, _encryptor._getEncryptor)(this._remote.encryptionKey);
     const sharedLimit = (0, _limitConcurrencyDecorator.limitConcurrency)(options.maxParallelOperations ?? DEFAULT_MAX_PARALLEL_OPERATIONS);
     this.closeFile = sharedLimit(this.closeFile);
     this.copy = sharedLimit(this.copy);
@@ -143,16 +115,13 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
   get type() {
     throw new Error('Not implemented');
   }
-
   addPrefix(prefix) {
     prefix = (0, _path.normalize)(prefix);
     return prefix === '/' ? this : new PrefixWrapper(this, prefix);
   }
-
   async closeFile(fd) {
     await this.__closeFile(fd);
   }
-
   async createReadStream(file, {
     checksum = false,
     ignoreMissingChecksum = false,
@@ -161,16 +130,15 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
     if (options.end !== undefined || options.start !== undefined) {
       _assert.default.strictEqual(this.isEncrypted, false, `Can't read part of a file when encryption is active ${file}`);
     }
-
     if (typeof file === 'string') {
       file = (0, _path.normalize)(file);
     }
-
-    let stream = await _promiseToolbox.timeout.call(this._createReadStream(file, { ...options,
+    let stream = await _promiseToolbox.timeout.call(this._createReadStream(file, {
+      ...options,
       highWaterMark: this._highWaterMark
     }), this._timeout);
-    await (0, _promiseToolbox.fromEvent)(stream, 'readable');
 
+    await (0, _promiseToolbox.fromEvent)(stream, 'readable');
     if (checksum) {
       try {
         const path = typeof file === 'string' ? file : file.path;
@@ -188,14 +156,14 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
         }
       }
     }
-
     if (this.isEncrypted) {
       stream = this._encryptor.decryptStream(stream);
     } else {
       if (stream.length === undefined && options.end === undefined && options.start === undefined) {
         try {
           stream.length = await this._getSize(file);
-        } catch (error) {}
+        } catch (error) {
+        }
       }
     }
 
@@ -210,18 +178,15 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
     path = (0, _path.normalize)(path);
     let checksumStream;
     input = this._encryptor.encryptStream(input);
-
     if (checksum) {
       checksumStream = (0, _checksum.createChecksumStream)();
       (0, _stream.pipeline)(input, checksumStream, noop);
       input = checksumStream;
     }
-
     await this._outputStream(path, input, {
       dirMode,
       validator
     });
-
     if (checksum) {
       await this._outputFile(checksumFile(path), await checksumStream.checksum, {
         dirMode,
@@ -233,18 +198,15 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
   async forget() {
     await this._forget();
   }
-
   async getInfo() {
     return _promiseToolbox.timeout.call(this._getInfo(), this._timeout);
   }
 
   async getSize(file) {
     _assert.default.strictEqual(this.isEncrypted, false, `Can't compute size of an encrypted file ${file}`);
-
     const size = await _promiseToolbox.timeout.call(this._getSize(typeof file === 'string' ? (0, _path.normalize)(file) : file), this._timeout);
     return size - this._encryptor.ivLength;
   }
-
   async list(dir, {
     filter,
     ignoreMissing = false,
@@ -254,34 +216,28 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       const virtualDir = (0, _path.normalize)(dir);
       dir = (0, _path.normalize)(dir);
       let entries = await _promiseToolbox.timeout.call(this._list(dir), this._timeout);
-
       if (filter !== undefined) {
         entries = entries.filter(filter);
       }
-
       if (prependDir) {
         entries.forEach((entry, i) => {
           entries[i] = virtualDir + '/' + entry;
         });
       }
-
       return entries;
     } catch (error) {
       if (ignoreMissing && (error === null || error === void 0 ? void 0 : error.code) === 'ENOENT') {
         return [];
       }
-
       throw error;
     }
   }
-
   async lock(path) {
     path = (0, _path.normalize)(path);
     return {
       dispose: await this._lock(path)
     };
   }
-
   async mkdir(dir, {
     mode
   } = {}) {
@@ -289,7 +245,6 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       mode
     });
   }
-
   async mktree(dir, {
     mode
   } = {}) {
@@ -297,29 +252,23 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       mode
     });
   }
-
   openFile(path, flags) {
     return this.__openFile(path, flags);
   }
-
   async outputFile(file, data, {
     dirMode,
     flags = 'wx'
   } = {}) {
     const encryptedData = this._encryptor.encryptData(data);
-
     await this._outputFile((0, _path.normalize)(file), encryptedData, {
       dirMode,
       flags
     });
   }
-
   async read(file, buffer, position) {
     _assert.default.strictEqual(this.isEncrypted, false, `Can't read part of an encrypted file ${file}`);
-
     return this._read(typeof file === 'string' ? (0, _path.normalize)(file) : file, buffer, position);
   }
-
   async readFile(file, {
     flags = 'r'
   } = {}) {
@@ -328,48 +277,52 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
     });
     return this._encryptor.decryptData(data);
   }
-
-  async rename(oldPath, newPath, {
+  async #rename(oldPath, newPath, {
+    checksum
+  }, createTree = true) {
+    try {
+      let p = _promiseToolbox.timeout.call(this._rename(oldPath, newPath), this._timeout);
+      if (checksum) {
+        p = Promise.all([p, this._rename(checksumFile(oldPath), checksumFile(newPath))]);
+      }
+      await p;
+    } catch (error) {
+      if (error.code === 'ENOENT' && createTree) {
+        await this._mktree((0, _path.dirname)(newPath));
+        return this.#rename(oldPath, newPath, {
+          checksum
+        }, false);
+      }
+      throw error;
+    }
+  }
+  rename(oldPath, newPath, {
     checksum = false
   } = {}) {
-    oldPath = (0, _path.normalize)(oldPath);
-    newPath = (0, _path.normalize)(newPath);
-
-    let p = _promiseToolbox.timeout.call(this._rename(oldPath, newPath), this._timeout);
-
-    if (checksum) {
-      p = Promise.all([p, this._rename(checksumFile(oldPath), checksumFile(newPath))]);
-    }
-
-    return p;
+    return this.#rename((0, _path.normalize)(oldPath), (0, _path.normalize)(newPath), {
+      checksum
+    });
   }
-
   async copy(oldPath, newPath, {
     checksum = false
   } = {}) {
     oldPath = (0, _path.normalize)(oldPath);
     newPath = (0, _path.normalize)(newPath);
-
     let p = _promiseToolbox.timeout.call(this._copy(oldPath, newPath), this._timeout);
-
     if (checksum) {
       p = Promise.all([p, this._copy(checksumFile(oldPath), checksumFile(newPath))]);
     }
-
     return p;
   }
-
   async rmdir(dir) {
     await _promiseToolbox.timeout.call(this._rmdir((0, _path.normalize)(dir)).catch(ignoreEnoent), this._timeout);
   }
-
   async rmtree(dir) {
     await this._rmtree((0, _path.normalize)(dir));
   }
 
   async sync() {
     await this._sync();
-
     try {
       await this._checkMetadata();
     } catch (error) {
@@ -377,56 +330,62 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       throw error;
     }
   }
-
   async _canWriteMetadata() {
     const list = await this.list('/', {
       filter: e => !e.startsWith('.') && e !== ENCRYPTION_DESC_FILENAME && e !== ENCRYPTION_METADATA_FILENAME
     });
     return list.length === 0;
   }
-
   async _createMetadata() {
+    const encryptionAlgorithm = this._remote.encryptionKey === undefined ? 'none' : _encryptor.DEFAULT_ENCRYPTION_ALGORITHM;
+    this.#encryptor = (0, _encryptor._getEncryptor)(encryptionAlgorithm, this._remote.encryptionKey);
     await Promise.all([this._writeFile((0, _path.normalize)(ENCRYPTION_DESC_FILENAME), JSON.stringify({
-      algorithm: this._encryptor.algorithm
+      algorithm: encryptionAlgorithm
     }), {
       flags: 'w'
-    }), this.writeFile(ENCRYPTION_METADATA_FILENAME, `{"random":"${(0, _crypto.randomUUID)()}"}`, {
+    }),
+    this.writeFile(ENCRYPTION_METADATA_FILENAME, `{"random":"${(0, _crypto.randomUUID)()}"}`, {
       flags: 'w'
     })]);
   }
 
   async _checkMetadata() {
+    let encryptionAlgorithm = 'none';
+    let data;
     try {
-      const data = await this._readFile((0, _path.normalize)(ENCRYPTION_DESC_FILENAME));
-      JSON.parse(data);
+      data = await this._readFile((0, _path.normalize)(ENCRYPTION_DESC_FILENAME), 'utf-8');
+      const json = JSON.parse(data);
+      encryptionAlgorithm = json.algorithm;
     } catch (error) {
       if (error.code !== 'ENOENT') {
         throw error;
       }
+      encryptionAlgorithm = this._remote.encryptionKey === undefined ? 'none' : _encryptor.DEFAULT_ENCRYPTION_ALGORITHM;
     }
-
     try {
-      const data = await this.readFile(ENCRYPTION_METADATA_FILENAME);
+      this.#encryptor = (0, _encryptor._getEncryptor)(encryptionAlgorithm, this._remote.encryptionKey);
+      const data = await this.readFile(ENCRYPTION_METADATA_FILENAME, 'utf-8');
       JSON.parse(data);
     } catch (error) {
-      if (error.code === 'ENOENT' || (await this._canWriteMetadata())) {
-        info('will update metadata of this remote');
-        return this._createMetadata();
+      if (encryptionAlgorithm !== 'none') {
+        if (await this._canWriteMetadata()) {
+
+          info('will update metadata of this remote');
+          return this._createMetadata();
+        } else {
+          warn(`The encryptionKey settings of this remote does not match the key used to create it. You won't be able to read any data from this remote`, {
+            error
+          });
+          throw error;
+        }
       }
-
-      warn(`The encryptionKey settings of this remote does not match the key used to create it. You won't be able to read any data from this remote`, {
-        error
-      });
-      throw error;
     }
   }
-
   async test() {
     const SIZE = 1024 * 1024 * 10;
     const testFileName = (0, _path.normalize)(`${Date.now()}.test`);
     const data = await (0, _promiseToolbox.fromCallback)(_crypto.randomBytes, SIZE);
     let step = 'write';
-
     try {
       const writeStart = process.hrtime();
       await this._outputFile(testFileName, data, {
@@ -439,11 +398,9 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
         flags: 'r'
       });
       const readDuration = process.hrtime(readStart);
-
       if (!data.equals(read)) {
         throw new Error('output and input did not match');
       }
-
       return {
         success: true,
         writeRate: computeRate(writeDuration, SIZE),
@@ -463,34 +420,26 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       _promiseToolbox.ignoreErrors.call(this._unlink(testFileName));
     }
   }
-
   async truncate(file, len) {
     await this._truncate(file, len);
   }
-
   async unlink(file, {
     checksum = true
   } = {}) {
     file = (0, _path.normalize)(file);
-
     if (checksum) {
       _promiseToolbox.ignoreErrors.call(this._unlink(checksumFile(file)));
     }
-
     await this._unlink(file).catch(ignoreEnoent);
   }
-
   async write(file, buffer, position) {
     _assert.default.strictEqual(this.isEncrypted, false, `Can't write part of a file with encryption ${file}`);
-
     await this._write(typeof file === 'string' ? (0, _path.normalize)(file) : file, buffer, position);
   }
-
   async writeFile(file, data, {
     flags = 'wx'
   } = {}) {
     const encryptedData = this._encryptor.encryptData(data);
-
     await this._writeFile((0, _path.normalize)(file), encryptedData, {
       flags
     });
@@ -499,7 +448,6 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
   async __closeFile(fd) {
     await _promiseToolbox.timeout.call(this._closeFile(fd.fd), this._timeout);
   }
-
   async __mkdir(dir, {
     mode
   } = {}) {
@@ -515,7 +463,6 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       await this._list(dir);
     }
   }
-
   async __openFile(path, flags) {
     path = (0, _path.normalize)(path);
     return {
@@ -527,17 +474,16 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
   useVhdDirectory() {
     return this._remote.useVhdDirectory ?? false;
   }
-
   async _closeFile(fd) {
     throw new Error('Not implemented');
   }
-
   async _createOutputStream(file, {
     dirMode,
     ...options
   } = {}) {
     try {
-      return await this._createWriteStream(file, { ...options,
+      return await this._createWriteStream(file, {
+        ...options,
         highWaterMark: this._highWaterMark
       });
     } catch (error) {
@@ -545,13 +491,11 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
         throw error;
       }
     }
-
     await this._mktree((0, _path.dirname)(file), {
       mode: dirMode
     });
     return this._createOutputStream(file, options);
   }
-
   async _createReadStream(file, options) {
     throw new Error('Not implemented');
   }
@@ -561,27 +505,21 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
   }
 
   async _forget() {}
-
   async _getInfo() {
     return {};
   }
-
   async _lock(path) {
     return () => Promise.resolve();
   }
-
   async _getSize(file) {
     throw new Error('Not implemented');
   }
-
   async _list(dir) {
     throw new Error('Not implemented');
   }
-
   async _mkdir(dir) {
     throw new Error('Not implemented');
   }
-
   async _mktree(dir, {
     mode
   } = {}) {
@@ -594,7 +532,6 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
         throw error;
       }
     }
-
     await this._mktree((0, _path.dirname)(dir), {
       mode
     });
@@ -602,11 +539,9 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       mode
     });
   }
-
   async _openFile(path, flags) {
     throw new Error('Not implemented');
   }
-
   async _outputFile(file, data, {
     dirMode,
     flags
@@ -620,7 +555,6 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
         throw error;
       }
     }
-
     await this._mktree((0, _path.dirname)(file), {
       mode: dirMode
     });
@@ -628,7 +562,6 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       flags
     });
   }
-
   async _outputStream(path, input, {
     dirMode,
     validator
@@ -638,43 +571,35 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       dirMode,
       flags: 'wx'
     }), this._timeout);
-
     try {
       await (0, _promiseToolbox.fromCallback)(_stream.pipeline, input, output);
-
       if (validator !== undefined) {
         await validator.call(this, tmpPath);
       }
-
       await this.rename(tmpPath, path);
     } catch (error) {
       await this.unlink(tmpPath);
       throw error;
     }
   }
-
   _read(file, buffer, position) {
     throw new Error('Not implemented');
   }
-
   _readFile(file, options) {
-    return this._createReadStream(file, { ...options,
+    return this._createReadStream(file, {
+      ...options,
       highWaterMark: this._highWaterMark
     }).then(_getStream.default.buffer);
   }
-
   async _rename(oldPath, newPath) {
     throw new Error('Not implemented');
   }
-
   async _copy(oldPath, newPath) {
     throw new Error('Not implemented');
   }
-
   async _rmdir(dir) {
     throw new Error('Not implemented');
   }
-
   async _rmtree(dir) {
     try {
       return await this._rmdir(dir);
@@ -683,31 +608,25 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
         throw error;
       }
     }
-
     const files = await this._list(dir);
     await (0, _legacy.default)(files, file => this._unlink(`${dir}/${file}`).catch(error => {
       if (error.code === 'EISDIR' || error.code === 'EPERM') {
         return this._rmtree(`${dir}/${file}`);
       }
-
       throw error;
     }));
     return this._rmtree(dir);
   }
 
   async _sync() {}
-
   async _unlink(file) {
     throw new Error('Not implemented');
   }
-
   async _write(file, buffer, position) {
     const isPath = typeof file === 'string';
-
     if (isPath) {
       file = await this.__openFile(file, 'r+');
     }
-
     try {
       return await this._writeFd(file, buffer, position);
     } finally {
@@ -716,22 +635,17 @@ let RemoteHandlerAbstract = (_dec = (0, _decoratorSynchronized.synchronized)(),
       }
     }
   }
-
   async _writeFd(fd, buffer, position) {
     throw new Error('Not implemented');
   }
-
   async _writeFile(file, data, options) {
     throw new Error('Not implemented');
   }
-
   get isEncrypted() {
     return this._encryptor.id !== 'NULL_ENCRYPTOR';
   }
-
 }, (_applyDecoratedDescriptor(_class.prototype, "forget", [_dec], Object.getOwnPropertyDescriptor(_class.prototype, "forget"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "sync", [_dec2], Object.getOwnPropertyDescriptor(_class.prototype, "sync"), _class.prototype)), _class));
 exports.default = RemoteHandlerAbstract;
-
 function createPrefixWrapperMethods() {
   const pPw = PrefixWrapper.prototype;
   const pRha = RemoteHandlerAbstract.prototype;
@@ -744,24 +658,18 @@ function createPrefixWrapperMethods() {
   } = Object;
   Object.getOwnPropertyNames(pRha).forEach(name => {
     let descriptor, value;
-
     if (hasOwnProperty.call(pPw, name) || name[0] === '_' || typeof (value = (descriptor = getOwnPropertyDescriptor(pRha, name)).value) !== 'function') {
       return;
     }
-
     descriptor.value = function () {
       let path;
-
       if (arguments.length !== 0 && typeof (path = arguments[0]) === 'string') {
         arguments[0] = this._resolve(path);
       }
-
       return value.apply(this._handler, arguments);
     };
-
     defineProperty(pPw, name, descriptor);
   });
 }
-
 createPrefixWrapperMethods();
 //# sourceMappingURL=abstract.js.map