refactor: pass logger to utils/common,qetag,storage

rocwind · rocwind · commit 935f7843deae · 2022-02-21T16:13:33.000+08:00
diff --git a/src/core/config.ts b/src/core/config.ts
@@ -105,7 +105,12 @@ export const config = {
         // data dir for caclulate diff files. it's optimization.
         dataDir: process.env.DATA_DIR || os.tmpdir(),
         // storageType which is your binary package files store. options value is ("local" | "qiniu" | "s3"| "oss" || "tencentcloud")
-        storageType: process.env.STORAGE_TYPE || 'local',
+        storageType: (process.env.STORAGE_TYPE || 'local') as
+            | 'local'
+            | 'qiniu'
+            | 's3'
+            | 'oss'
+            | 'tencentcloud',
         // options value is (true | false), when it's true, it will cache updateCheck results in redis.
         updateCheckCache: toBool(process.env.UPDATE_CHECK_CACHE),
         // options value is (true | false), when it's true, it will cache rollout results in redis
diff --git a/src/core/services/package-manager.ts b/src/core/services/package-manager.ts
@@ -205,16 +205,19 @@ class PackageManager {
                 return dataCenterManager.getPackageInfo(packageHash);
             }
             const downloadURL = getBlobDownloadUrl(blobHash);
-            return createFileFromRequest(downloadURL, path.join(workDirectoryPath, blobHash)).then(
-                () => {
-                    return unzipFile(
-                        path.join(workDirectoryPath, blobHash),
-                        path.join(workDirectoryPath, 'current'),
-                    ).then((outputPath) => {
-                        return dataCenterManager.storePackage(outputPath, true, logger);
-                    });
-                },
-            );
+            return createFileFromRequest(
+                downloadURL,
+                path.join(workDirectoryPath, blobHash),
+                logger,
+            ).then(() => {
+                return unzipFile(
+                    path.join(workDirectoryPath, blobHash),
+                    path.join(workDirectoryPath, 'current'),
+                    logger,
+                ).then((outputPath) => {
+                    return dataCenterManager.storePackage(outputPath, true, logger);
+                });
+            });
         });
     }
 
@@ -269,6 +272,7 @@ class PackageManager {
             return createFileFromRequest(
                 downloadURL,
                 path.join(workDirectoryPath, diffManifestBlobHash),
+                logger,
             ).then(() => {
                 const dataCenterContentPath = path.join(workDirectoryPath, 'dataCenter');
                 copySync(originDataCenter.contentPath, dataCenterContentPath);
@@ -294,8 +298,8 @@ class PackageManager {
                     dataCenterContentPath,
                     hotCodePushFile,
                 ).then((data) => {
-                    return qetag(data.path).then((diffHash) => {
-                        return uploadFileToStorage(diffHash, fileName).then(() => {
+                    return qetag(data.path, logger).then((diffHash) => {
+                        return uploadFileToStorage(diffHash, fileName, logger).then(() => {
                             const stats = fs.statSync(fileName);
                             return PackagesDiff.create({
                                 package_id: packageId,
@@ -413,9 +417,9 @@ class PackageManager {
         const directoryPath = path.join(directoryPathParent, 'current');
         logger.debug(`releasePackage generate an random dir path: ${directoryPath}`);
         return Promise.all([
-            qetag(filePath),
+            qetag(filePath, logger),
             createEmptyFolder(directoryPath).then(() => {
-                return unzipFile(filePath, directoryPath);
+                return unzipFile(filePath, directoryPath, logger);
             }),
         ])
             .then(([blobHash]) => {
@@ -463,12 +467,12 @@ class PackageManager {
                                     logger.debug(e.message);
                                     throw e;
                                 }
-                                return qetag(manifestFile);
+                                return qetag(manifestFile, logger);
                             })
                             .then((manifestHash) => {
                                 return Promise.all([
-                                    uploadFileToStorage(manifestHash, manifestFile),
-                                    uploadFileToStorage(blobHash, filePath),
+                                    uploadFileToStorage(manifestHash, manifestFile, logger),
+                                    uploadFileToStorage(blobHash, filePath, logger),
                                 ]).then(() => [packageHash, manifestHash, blobHash]);
                             });
                     });
diff --git a/src/core/utils/common.ts b/src/core/utils/common.ts
@@ -4,7 +4,7 @@ import { pipeline } from 'stream';
 import util from 'util';
 import extract from 'extract-zip';
 import fsextra from 'fs-extra';
-import { logger } from 'kv-logger';
+import { Logger } from 'kv-logger';
 import _ from 'lodash';
 import fetch from 'node-fetch';
 import validator from 'validator';
@@ -87,7 +87,7 @@ export function validatorVersion(versionNo: string) {
     return [flag, min, max];
 }
 
-export async function createFileFromRequest(url, filePath) {
+export async function createFileFromRequest(url: string, filePath: string, logger: Logger) {
     try {
         await fs.promises.stat(filePath);
         return;
@@ -135,37 +135,33 @@ export function createEmptyFolderSync(folderPath: string) {
     fsextra.mkdirsSync(folderPath);
 }
 
-export async function unzipFile(zipFile: string, outputPath: string) {
+export async function unzipFile(zipFile: string, outputPath: string, logger: Logger) {
     try {
         logger.debug(`unzipFile check zipFile ${zipFile} fs.R_OK`);
         fs.accessSync(zipFile, fs.constants.R_OK);
         logger.debug(`Pass unzipFile file ${zipFile}`);
     } catch (err) {
-        logger.error(err);
         throw new AppError(err.message);
     }
 
     try {
         await extract(zipFile, { dir: outputPath });
         logger.debug(`unzipFile success`);
     } catch (err) {
-        logger.error(err);
         throw new AppError(`it's not a zipFile`);
     }
     return outputPath;
 }
 
 export function getBlobDownloadUrl(blobUrl: string): string {
     let fileName = blobUrl;
-    const storageType = _.get(config, 'common.storageType');
-    const downloadUrl = _.get(config, `${storageType}.downloadUrl`);
+    const { storageType } = config.common;
+    const { downloadUrl } = config[storageType];
     if (storageType === 'local') {
         fileName = `${blobUrl.substring(0, 2).toLowerCase()}/${blobUrl}`;
     }
     if (!validator.isURL(downloadUrl)) {
-        const e = new AppError(`Please config ${storageType}.downloadUrl in config.js`);
-        logger.error(e);
-        throw e;
+        throw new AppError(`Please config ${storageType}.downloadUrl in config.js`);
     }
     return `${downloadUrl}/${fileName}`;
 }
diff --git a/src/core/utils/qetag.ts b/src/core/utils/qetag.ts
@@ -2,7 +2,7 @@ import { Buffer } from 'buffer';
 import crypto from 'crypto';
 import fs from 'fs';
 import { Stream, Readable } from 'stream';
-import { logger } from 'kv-logger';
+import { Logger } from 'kv-logger';
 import { AppError } from '../app-error';
 
 // 计算文件的eTag，参数为buffer或者readableStream或者文件路径
@@ -87,7 +87,7 @@ function getEtag(buffer: string | Stream | Buffer, callback: (etag: string) => v
 }
 
 // TODO: support only files (string)?
-export function qetag(buffer: string | Stream | Buffer): Promise<string> {
+export function qetag(buffer: string | Stream | Buffer, logger: Logger): Promise<string> {
     if (typeof buffer === 'string') {
         // it's a file
         try {
diff --git a/src/core/utils/storage.ts b/src/core/utils/storage.ts
@@ -5,14 +5,14 @@ import ALY from 'aliyun-sdk';
 import AWS from 'aws-sdk';
 import COS from 'cos-nodejs-sdk-v5';
 import fsextra from 'fs-extra';
-import { logger } from 'kv-logger';
+import { Logger } from 'kv-logger';
 import _ from 'lodash';
 import qiniu from 'qiniu';
 
 import { AppError } from '../app-error';
 import { config } from '../config';
 
-function uploadFileToLocal(key: string, filePath: string): Promise<void> {
+function uploadFileToLocal(key: string, filePath: string, logger: Logger): Promise<void> {
     return new Promise((resolve, reject) => {
         logger.info(`try uploadFileToLocal`, {
             key,
@@ -76,7 +76,7 @@ function uploadFileToLocal(key: string, filePath: string): Promise<void> {
     });
 }
 
-function uploadFileToS3(key: string, filePath: string): Promise<void> {
+function uploadFileToS3(key: string, filePath: string, logger: Logger): Promise<void> {
     return new Promise((resolve, reject) => {
         logger.info('try uploadFileToS3', { key });
         AWS.config.update({
@@ -111,7 +111,7 @@ function uploadFileToS3(key: string, filePath: string): Promise<void> {
     });
 }
 
-function uploadFileToOSS(key: string, filePath: string): Promise<void> {
+function uploadFileToOSS(key: string, filePath: string, logger: Logger): Promise<void> {
     logger.info('try uploadFileToOSS', { key });
     const ossStream = ALYOSSStream(
         new ALY.OSS({
@@ -151,7 +151,7 @@ function getUploadTokenQiniu(mac: qiniu.auth.digest.Mac, bucket: string, key: st
     return putPolicy.uploadToken(mac);
 }
 
-function uploadFileToQiniu(key: string, filePath: string): Promise<void> {
+function uploadFileToQiniu(key: string, filePath: string, logger: Logger): Promise<void> {
     return new Promise((resolve, reject) => {
         logger.info('try uploadFileToQiniu', { key });
         const accessKey = _.get(config, 'qiniu.accessKey');
@@ -202,7 +202,7 @@ function uploadFileToQiniu(key: string, filePath: string): Promise<void> {
     });
 }
 
-function uploadFileToTencentCloud(key: string, filePath: string): Promise<void> {
+function uploadFileToTencentCloud(key: string, filePath: string, logger: Logger): Promise<void> {
     return new Promise((resolve, reject) => {
         logger.info('try uploadFileToTencentCloud', { key });
         const cosIn = new COS({
@@ -228,19 +228,19 @@ function uploadFileToTencentCloud(key: string, filePath: string): Promise<void>
     });
 }
 
-export function uploadFileToStorage(key: string, filePath: string): Promise<void> {
-    const storageType = _.get(config, 'common.storageType');
+export function uploadFileToStorage(key: string, filePath: string, logger: Logger): Promise<void> {
+    const { storageType } = config.common;
     switch (storageType) {
         case 'local':
-            return uploadFileToLocal(key, filePath);
+            return uploadFileToLocal(key, filePath, logger);
         case 's3':
-            return uploadFileToS3(key, filePath);
+            return uploadFileToS3(key, filePath, logger);
         case 'oss':
-            return uploadFileToOSS(key, filePath);
+            return uploadFileToOSS(key, filePath, logger);
         case 'qiniu':
-            return uploadFileToQiniu(key, filePath);
+            return uploadFileToQiniu(key, filePath, logger);
         case 'tencentcloud':
-            return uploadFileToTencentCloud(key, filePath);
+            return uploadFileToTencentCloud(key, filePath, logger);
         default:
             throw new AppError(`${storageType} storageType does not support.`);
     }
