@xen-orchestra/fs 0.20.0 → 1.0.0

package/dist/s3.js

@@ -5,13 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _awsSdk = _interopRequireDefault(require("@sullux/aws-sdk"));
+var _clientS = require("@aws-sdk/client-s3");
+
+var _libStorage = require("@aws-sdk/lib-storage");
+
+var _nodeHttpHandler = require("@aws-sdk/node-http-handler");
 
 var _assert = _interopRequireDefault(require("assert"));
 
-var _http = _interopRequireDefault(require("http"));
+var _http = require("http");
 
-var _https = _interopRequireDefault(require("https"));
+var _https = require("https");
 
 var _retry = _interopRequireDefault(require("promise-toolbox/retry"));
 
@@ -19,10 +23,20 @@ var _log = require("@xen-orchestra/log");
 
 var _decorateWith = require("@vates/decorate-with");
 
+var _stream = require("stream");
+
 var _xoRemoteParser = require("xo-remote-parser");
 
+var _copyStreamToBuffer = _interopRequireDefault(require("./_copyStreamToBuffer.js"));
+
+var _createBufferFromStream = _interopRequireDefault(require("./_createBufferFromStream.js"));
+
+var _guessAwsRegion = _interopRequireDefault(require("./_guessAwsRegion.js"));
+
 var _abstract = _interopRequireDefault(require("./abstract"));
 
+var _path = require("./_path");
+
 var _asyncEach = require("@vates/async-each");
 
 var _dec, _class;
@@ -41,7 +55,11 @@ const {
 } = (0, _log.createLogger)('xo:fs:s3');
 let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
   delays: [100, 200, 500, 1000, 2000],
-  when: e => e.code === 'InternalError',
+  when: e => {
+    var _e$$metadata;
+
+    return ((_e$$metadata = e.$metadata) === null || _e$$metadata === void 0 ? void 0 : _e$$metadata.httpStatusCode) === 500;
+  },
 
   onRetry(error) {
     warn('retrying writing file', {
@@ -62,100 +80,103 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
       username,
       password,
       protocol,
-      region
+      region = (0, _guessAwsRegion.default)(host)
     } = (0, _xoRemoteParser.parse)(remote.url);
-    const params = {
-      accessKeyId: username,
+    this._s3 = new _clientS.S3Client({
       apiVersion: '2006-03-01',
-      endpoint: host,
-      s3ForcePathStyle: true,
-      secretAccessKey: password,
-      signatureVersion: 'v4',
-      httpOptions: {
-        timeout: 600000
-      }
-    };
+      endpoint: `${protocol}://${host}`,
+      forcePathStyle: true,
+      credentials: {
+        accessKeyId: username,
+        secretAccessKey: password
+      },
+      tls: protocol === 'https',
+      region,
+      requestHandler: new _nodeHttpHandler.NodeHttpHandler({
+        socketTimeout: 600000,
+        httpAgent: new _http.Agent({
+          keepAlive: true
+        }),
+        httpsAgent: new _https.Agent({
+          rejectUnauthorized: !allowUnauthorized,
+          keepAlive: true
+        })
+      })
+    });
+    const parts = (0, _path.split)(path);
+    this._bucket = parts.shift();
+    this._dir = (0, _path.join)(...parts);
+  }
 
-    if (protocol === 'http') {
-      params.httpOptions.agent = new _http.default.Agent({
-        keepAlive: true
-      });
-      params.sslEnabled = false;
-    } else if (protocol === 'https') {
-      params.httpOptions.agent = new _https.default.Agent({
-        rejectUnauthorized: !allowUnauthorized,
-        keepAlive: true
-      });
-    }
+  get type() {
+    return 's3';
+  }
 
-    if (region !== undefined) {
-      params.region = region;
-    }
+  _makeCopySource(path) {
+    return (0, _path.join)(this._bucket, this._dir, path);
+  }
 
-    this._s3 = (0, _awsSdk.default)(params).s3;
-    const splitPath = path.split('/').filter(s => s.length);
-    this._bucket = splitPath.shift();
-    this._dir = splitPath.join('/');
+  _makeKey(file) {
+    return (0, _path.join)(this._dir, file);
   }
 
-  get type() {
-    return 's3';
+  _makePrefix(dir) {
+    return (0, _path.join)(this._dir, dir, '/');
   }
 
   _createParams(file) {
     return {
       Bucket: this._bucket,
-      Key: this._dir + file
+      Key: this._makeKey(file)
     };
   }
 
   async _multipartCopy(oldPath, newPath) {
     const size = await this._getSize(oldPath);
-    const CopySource = `/${this._bucket}/${this._dir}${oldPath}`;
-    const multipartParams = await this._s3.createMultipartUpload({ ...this._createParams(newPath)
-    });
-    const param2 = { ...multipartParams,
-      CopySource
-    };
+
+    const CopySource = this._makeCopySource(oldPath);
+
+    const multipartParams = await this._s3.send(new _clientS.CreateMultipartUploadCommand({ ...this._createParams(newPath)
+    }));
 
     try {
       const parts = [];
       let start = 0;
 
       while (start < size) {
-        const range = `bytes=${start}-${Math.min(start + MAX_PART_SIZE, size) - 1}`;
-        const partParams = { ...param2,
-          PartNumber: parts.length + 1,
-          CopySourceRange: range
-        };
-        const upload = await this._s3.uploadPartCopy(partParams);
+        const partNumber = parts.length + 1;
+        const upload = await this._s3.send(new _clientS.UploadPartCopyCommand({ ...multipartParams,
+          CopySource,
+          CopySourceRange: `bytes=${start}-${Math.min(start + MAX_PART_SIZE, size) - 1}`,
+          PartNumber: partNumber
+        }));
         parts.push({
           ETag: upload.CopyPartResult.ETag,
-          PartNumber: partParams.PartNumber
+          PartNumber: partNumber
         });
         start += MAX_PART_SIZE;
       }
 
-      await this._s3.completeMultipartUpload({ ...multipartParams,
+      await this._s3.send(new _clientS.CompleteMultipartUploadCommand({ ...multipartParams,
         MultipartUpload: {
           Parts: parts
         }
-      });
+      }));
     } catch (e) {
-      await this._s3.abortMultipartUpload(multipartParams);
+      await this._s3.send(new _clientS.AbortMultipartUploadCommand(multipartParams));
       throw e;
     }
   }
 
   async _copy(oldPath, newPath) {
-    const CopySource = `/${this._bucket}/${this._dir}${oldPath}`;
+    const CopySource = this._makeCopySource(oldPath);
 
     try {
-      await this._s3.copyObject({ ...this._createParams(newPath),
+      await this._s3.send(new _clientS.CopyObjectCommand({ ...this._createParams(newPath),
         CopySource
-      });
+      }));
     } catch (e) {
-      if (e.code === 'EntityTooLarge') {
+      if (e.name === 'EntityTooLarge') {
         return this._multipartCopy(oldPath, newPath);
       }
 
@@ -164,20 +185,22 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
   }
 
   async _isNotEmptyDir(path) {
-    const result = await this._s3.listObjectsV2({
+    var _result$Contents;
+
+    const result = await this._s3.send(new _clientS.ListObjectsV2Command({
       Bucket: this._bucket,
       MaxKeys: 1,
-      Prefix: this._dir + path + '/'
-    });
-    return result.Contents.length !== 0;
+      Prefix: this._makePrefix(path)
+    }));
+    return ((_result$Contents = result.Contents) === null || _result$Contents === void 0 ? void 0 : _result$Contents.length) > 0;
   }
 
   async _isFile(path) {
     try {
-      await this._s3.headObject(this._createParams(path));
+      await this._s3.send(new _clientS.HeadObjectCommand(this._createParams(path)));
       return true;
     } catch (error) {
-      if (error.code === 'NotFound') {
+      if (error.name === 'NotFound') {
         return false;
       }
 
@@ -188,12 +211,17 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
   async _outputStream(path, input, {
     validator
   }) {
-    await this._s3.upload({ ...this._createParams(path),
-      Body: input
-    }, {
+    const Body = new _stream.PassThrough();
+    (0, _stream.pipeline)(input, Body, () => {});
+    const upload = new _libStorage.Upload({
+      client: this._s3,
+      queueSize: 1,
       partSize: IDEAL_FRAGMENT_SIZE,
-      queueSize: 1
+      params: { ...this._createParams(path),
+        Body
+      }
     });
+    await upload.done();
 
     if (validator !== undefined) {
       try {
@@ -206,9 +234,9 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
   }
 
   async _writeFile(file, data, options) {
-    return this._s3.putObject({ ...this._createParams(file),
+    return this._s3.send(new _clientS.PutObjectCommand({ ...this._createParams(file),
       Body: data
-    });
+    }));
   }
 
   async _createReadStream(path, options) {
@@ -219,11 +247,11 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
       throw error;
     }
 
-    return this._s3.getObject.raw(this._createParams(path)).createReadStream();
+    return (await this._s3.send(new _clientS.GetObjectCommand(this._createParams(path)))).Body;
   }
 
   async _unlink(path) {
-    await this._s3.deleteObject(this._createParams(path));
+    await this._s3.send(new _clientS.DeleteObjectCommand(this._createParams(path)));
 
     if (await this._isNotEmptyDir(path)) {
       const error = new Error(`EISDIR: illegal operation on a directory, unlink '${path}'`);
@@ -234,37 +262,36 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
   }
 
   async _list(dir) {
-    function splitPath(path) {
-      return path.split('/').filter(d => d.length);
-    }
+    let NextContinuationToken;
+    const uniq = new Set();
 
-    const prefix = [this._dir, dir].join('/');
-    const splitPrefix = splitPath(prefix);
-    const result = await this._s3.listObjectsV2({
-      Bucket: this._bucket,
-      Prefix: splitPrefix.join('/') + '/',
-      Delimiter: '/'
-    });
+    const Prefix = this._makePrefix(dir);
 
-    if (result.IsTruncated) {
-      const error = new Error('more than 1000 objects, unsupported in this implementation');
-      error.dir = dir;
-      throw error;
-    }
+    do {
+      const result = await this._s3.send(new _clientS.ListObjectsV2Command({
+        Bucket: this._bucket,
+        Prefix,
+        Delimiter: '/',
+        ContinuationToken: NextContinuationToken
+      }));
 
-    const uniq = [];
+      if (result.IsTruncated) {
+        warn(`need pagination to browse the directory ${dir} completely`);
+        NextContinuationToken = result.NextContinuationToken;
+      } else {
+        NextContinuationToken = undefined;
+      }
 
-    for (const entry of result.CommonPrefixes) {
-      const line = splitPath(entry.Prefix);
-      uniq.push(line[line.length - 1]);
-    }
+      for (const entry of result.CommonPrefixes ?? []) {
+        uniq.add((0, _path.basename)(entry.Prefix));
+      }
 
-    for (const entry of result.Contents) {
-      const line = splitPath(entry.Key);
-      uniq.push(line[line.length - 1]);
-    }
+      for (const entry of result.Contents ?? []) {
+        uniq.add((0, _path.basename)(entry.Key));
+      }
+    } while (NextContinuationToken !== undefined);
 
-    return uniq;
+    return [...uniq];
   }
 
   async _mkdir(path) {
@@ -278,7 +305,7 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
 
   async _rename(oldPath, newPath) {
     await this.copy(oldPath, newPath);
-    await this._s3.deleteObject(this._createParams(oldPath));
+    await this._s3.send(new _clientS.DeleteObjectCommand(this._createParams(oldPath)));
   }
 
   async _getSize(file) {
@@ -286,7 +313,7 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
       file = file.fd;
     }
 
-    const result = await this._s3.headObject(this._createParams(file));
+    const result = await this._s3.send(new _clientS.HeadObjectCommand(this._createParams(file)));
     return +result.ContentLength;
   }
 
@@ -300,14 +327,14 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
     params.Range = `bytes=${position}-${position + buffer.length - 1}`;
 
     try {
-      const result = await this._s3.getObject(params);
-      result.Body.copy(buffer);
+      const result = await this._s3.send(new _clientS.GetObjectCommand(params));
+      const bytesRead = await (0, _copyStreamToBuffer.default)(result.Body, buffer);
       return {
-        bytesRead: result.Body.length,
+        bytesRead,
         buffer
       };
     } catch (e) {
-      if (e.code === 'NoSuchKey') {
+      if (e.name === 'NoSuchKey') {
         if (await this._isNotEmptyDir(file)) {
           const error = new Error(`${file} is a directory`);
           error.code = 'EISDIR';
@@ -332,20 +359,22 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
   async _rmtree(path) {
     let NextContinuationToken;
 
+    const Prefix = this._makePrefix(path);
+
     do {
-      const result = await this._s3.listObjectsV2({
+      const result = await this._s3.send(new _clientS.ListObjectsV2Command({
         Bucket: this._bucket,
-        Prefix: this._dir + path + '/',
+        Prefix,
         ContinuationToken: NextContinuationToken
-      });
+      }));
       NextContinuationToken = result.IsTruncated ? result.NextContinuationToken : undefined;
-      await (0, _asyncEach.asyncEach)(result.Contents, async ({
+      await (0, _asyncEach.asyncEach)(result.Contents ?? [], async ({
         Key
       }) => {
-        await this._s3.deleteObject({
+        await this._s3.send(new _clientS.DeleteObjectCommand({
           Bucket: this._bucket,
           Key
-        });
+        }));
       }, {
         concurrency: 16
       });
@@ -362,9 +391,9 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
     let fileSize;
 
     try {
-      fileSize = +(await this._s3.headObject(uploadParams)).ContentLength;
+      fileSize = +(await this._s3.send(new _clientS.HeadObjectCommand(uploadParams))).ContentLength;
     } catch (e) {
-      if (e.code === 'NotFound') {
+      if (e.name === 'NotFound') {
         fileSize = 0;
       } else {
         throw e;
@@ -373,20 +402,26 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
 
     if (fileSize < MIN_PART_SIZE) {
       const resultBuffer = Buffer.alloc(Math.max(fileSize, position + buffer.length));
-      const fileContent = fileSize !== 0 ? (await this._s3.getObject(uploadParams)).Body : Buffer.alloc(0);
-      fileContent.copy(resultBuffer);
+
+      if (fileSize !== 0) {
+        const result = await this._s3.send(new _clientS.GetObjectCommand(uploadParams));
+        await (0, _copyStreamToBuffer.default)(result.Body, resultBuffer);
+      } else {
+        Buffer.alloc(0).copy(resultBuffer);
+      }
+
       buffer.copy(resultBuffer, position);
-      await this._s3.putObject({ ...uploadParams,
+      await this._s3.send(new _clientS.PutObjectCommand({ ...uploadParams,
         Body: resultBuffer
-      });
+      }));
       return {
         buffer,
         bytesWritten: buffer.length
       };
     } else {
-      const multipartParams = await this._s3.createMultipartUpload(uploadParams);
+      const multipartParams = await this._s3.send(new _clientS.CreateMultipartUploadCommand(uploadParams));
       const copyMultipartParams = { ...multipartParams,
-        CopySource: `/${this._bucket}/${this._dir + file}`
+        CopySource: this._makeCopySource(file)
       };
 
       try {
@@ -418,7 +453,7 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
             PartNumber: partNumber++,
             CopySourceRange: range
           };
-          const part = await this._s3.uploadPartCopy(copyPrefixParams);
+          const part = await this._s3.send(new _clientS.UploadPartCopyCommand(copyPrefixParams));
           parts.push({
             ETag: part.CopyPartResult.ETag,
             PartNumber: copyPrefixParams.PartNumber
@@ -430,7 +465,15 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
           const downloadParams = { ...uploadParams,
             Range: `bytes=${prefixPosition}-${prefixSize - 1}`
           };
-          const prefixBuffer = prefixSize > 0 ? (await this._s3.getObject(downloadParams)).Body : Buffer.alloc(0);
+          let prefixBuffer;
+
+          if (prefixSize > 0) {
+            const result = await this._s3.send(new _clientS.GetObjectCommand(downloadParams));
+            prefixBuffer = await (0, _createBufferFromStream.default)(result.Body);
+          } else {
+            prefixBuffer = Buffer.alloc(0);
+          }
+
           editBuffer = Buffer.concat([prefixBuffer, buffer]);
           editBufferOffset -= prefixLastFragmentSize;
         }
@@ -445,7 +488,8 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
           const downloadParams = { ...uploadParams,
             Range: prefixRange
           };
-          const complementBuffer = (await this._s3.getObject(downloadParams)).Body;
+          const result = await this._s3.send(new _clientS.GetObjectCommand(downloadParams));
+          const complementBuffer = await (0, _createBufferFromStream.default)(result.Body);
           editBuffer = Buffer.concat([editBuffer, complementBuffer]);
         }
 
@@ -453,7 +497,7 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
           Body: editBuffer,
           PartNumber: partNumber++
         };
-        const editPart = await this._s3.uploadPart(editParams);
+        const editPart = await this._s3.send(new _clientS.UploadPartCommand(editParams));
         parts.push({
           ETag: editPart.ETag,
           PartNumber: editParams.PartNumber
@@ -473,7 +517,7 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
               PartNumber: partNumber++,
               CopySourceRange: suffixRange
             };
-            const suffixPart = (await this._s3.uploadPartCopy(copySuffixParams)).CopyPartResult;
+            const suffixPart = (await this._s3.send(new _clientS.UploadPartCopyCommand(copySuffixParams))).CopyPartResult;
             parts.push({
               ETag: suffixPart.ETag,
               PartNumber: copySuffixParams.PartNumber
@@ -482,13 +526,13 @@ let S3Handler = (_dec = (0, _decorateWith.decorateWith)(_retry.default.wrap, {
           }
         }
 
-        await this._s3.completeMultipartUpload({ ...multipartParams,
+        await this._s3.send(new _clientS.CompleteMultipartUploadCommand({ ...multipartParams,
           MultipartUpload: {
             Parts: parts
           }
-        });
+        }));
       } catch (e) {
-        await this._s3.abortMultipartUpload(multipartParams);
+        await this._s3.send(new _clientS.AbortMultipartUploadCommand(multipartParams));
         throw e;
       }
     }