add debug log

Author: lisong

bin/www

@@ -119,5 +119,5 @@ function onListening() {
   var bind = typeof addr === 'string'
     ? 'pipe ' + addr
     : 'port ' + addr.port;
-  log.debug('Listening on ' + bind);
+  log.info('Listening on ' + bind);
 }

config/config.js

@@ -105,6 +105,7 @@ config.development.log4js = {
   ],
   levels : {
     "[all]": "ERROR",
+    "startup": "INFO",
     "http" : "INFO"
   }
 }

config/config.test.js

@@ -52,6 +52,7 @@ config.test.log4js = {
   ],
   levels : {
     "[all]": "ERROR",
+    "startup": "INFO",
     "http" : "INFO"
   }
 }

config/config.testwin.js

@@ -53,6 +53,7 @@ config.test.log4js = {
   ],
   levels : {
     "[all]": "ERROR",
+    "startup": "INFO",
     "http" : "INFO"
   }
 }

core/services/datacenter-manager.js

@@ -9,6 +9,8 @@ var common = require('../utils/common');
 const MANIFEST_FILE_NAME = 'manifest.json';
 const CONTENTS_NAME = 'contents';
 var AppError = require('../app-error');
+var log4js = require('log4js');
+var log = log4js.getLogger("cps:DataCenterManager");
 
 var proto = module.exports = function (){
   function DataCenterManager() {
@@ -61,48 +63,60 @@ proto.validateStore = function (providePackageHash) {
   var manifestFile = `${packageHashPath}/${MANIFEST_FILE_NAME}`;
   var contentPath = `${packageHashPath}/${CONTENTS_NAME}`;
   if (!this.hasPackageStoreSync(providePackageHash)) {
+    log.debug(`validateStore providePackageHash not exist`);
     return Promise.resolve(false);
   }
   return security.calcAllFileSha256(contentPath)
   .then((manifestJson) => {
     var packageHash = security.packageHashSync(manifestJson);
+    log.debug(`validateStore packageHash:`, packageHash);
     try {
       var manifestJsonLocal = JSON.parse(fs.readFileSync(manifestFile));
     }catch(e) {
+      log.debug(`validateStore manifestFile contents invilad`);
       return false;
     }
     var packageHashLocal = security.packageHashSync(manifestJsonLocal);
+    log.debug(`validateStore packageHashLocal:`, packageHashLocal);
     if (_.eq(providePackageHash, packageHash) && _.eq(providePackageHash, packageHashLocal)) {
+      log.debug(`validateStore store files is ok`);
       return true;
     }
+    log.debug(`validateStore store files broken`);
     return false;
   });
 }
 
 proto.storePackage = function (sourceDst, force) {
+  log.debug(`storePackage sourceDst:`, sourceDst);
   if (_.isEmpty(force)){
     force = false;
   }
   var self = this;
   return security.calcAllFileSha256(sourceDst)
   .then((manifestJson) => {
     var packageHash = security.packageHashSync(manifestJson);
+    log.debug('storePackage manifestJson packageHash:', packageHash);
     var dataDir = self.getDataDir();
     var packageHashPath = `${dataDir}/${packageHash}`;
     var manifestFile = `${packageHashPath}/${MANIFEST_FILE_NAME}`;
     var contentPath = `${packageHashPath}/${CONTENTS_NAME}`;
-    if (!force && self.hasPackageStoreSync(packageHash)) {
-      return self.buildPackageInfo(packageHash, packageHashPath, contentPath, manifestFile);
-    } else {
-      return common.createEmptyFolder(packageHashPath)
-      .then(() => {
-        return common.move(sourceDst, contentPath)
+    return self.validateStore(packageHash)
+    .then((isValidate) => {
+      if (!force && isValidate) {
+        return self.buildPackageInfo(packageHash, packageHashPath, contentPath, manifestFile);
+      } else {
+        log.debug(`storePackage cover from sourceDst:`, sourceDst);
+        return common.createEmptyFolder(packageHashPath)
         .then(() => {
-          var manifestString = JSON.stringify(manifestJson);
-          fs.writeFileSync(manifestFile, manifestString);
-          return self.buildPackageInfo(packageHash, packageHashPath, contentPath, manifestFile);
+          return common.move(sourceDst, contentPath)
+          .then(() => {
+            var manifestString = JSON.stringify(manifestJson);
+            fs.writeFileSync(manifestFile, manifestString);
+            return self.buildPackageInfo(packageHash, packageHashPath, contentPath, manifestFile);
+          });
         });
-      });
-    }
+      }
+    });
   });
 }

core/services/package-manager.js

@@ -50,35 +50,35 @@ proto.parseReqFile = function (req) {
   });
 };
 
-proto.getDeploymentsVersions = function (deploymentId, appVersion) {
-  return models.DeploymentsVersions.findOne({
-    where: {deployment_id: deploymentId, app_version: appVersion}
+proto.createDeploymentsVersionIfNotExist = function (deploymentId, appVersion, t) {
+  return models.DeploymentsVersions.findOrCreate({
+    where: {deployment_id: deploymentId, app_version: appVersion},
+    defaults: {current_package_id: 0},
+    transaction: t
+  })
+  .spread((data, created)=>{
+    if (created) {
+      log.debug(`createDeploymentsVersionIfNotExist findOrCreate version ${appVersion}`);
+    }
+    log.debug(`createDeploymentsVersionIfNotExist version data:`, data.get());
+    return data;
   });
 };
 
-proto.existPackageHashAndCreateVersions = function (deploymentId, appVersion, packageHash) {
-  return this.getDeploymentsVersions(deploymentId, appVersion)
+proto.isMatchPackageHash = function (packageId, packageHash) {
+  if (_.lt(packageId, 0)) {
+    log.debug(`isMatchPackageHash packageId is 0`);
+    return Promise.resolve(false);
+  }
+  return models.Packages.findById(packageId)
   .then((data) => {
-    if (_.isEmpty(data)){
-      return models.DeploymentsVersions.create({
-        deployment_id: deploymentId,
-        app_version: appVersion,
-      })
-      .then(() => false);
-    } else {
-      var packageId = data.current_package_id;
-      if (_.gt(packageId, 0)) {
-        return models.Packages.findById(packageId)
-        .then((data) => {
-          if (_.eq(_.get(data,"package_hash"), packageHash)){
-            return true;
-          }else {
-            return false;
-          }
-        });
-      } else {
-        return false
-      }
+    if (data && _.eq(data.get('package_hash'), packageHash)){
+      log.debug(`isMatchPackageHash data:`, data.get());
+      log.debug(`isMatchPackageHash packageHash exist`);
+      return true;
+    }else {
+      log.debug(`isMatchPackageHash package is null`);
+      return false;
     }
   });
 };
@@ -91,20 +91,11 @@ proto.createPackage = function (deploymentId, appVersion, packageHash, manifestH
   var description = params.description || "";
   var originalLabel = params.originalLabel || "";
   var originalDeployment = params.originalDeployment || "";
+  var self = this;
   return models.Deployments.generateLabelId(deploymentId)
   .then((labelId) => {
     return models.sequelize.transaction((t) => {
-      return models.DeploymentsVersions.findOne({where: {deployment_id: deploymentId, app_version: appVersion}})
-      .then((deploymentsVersions) => {
-        if (!deploymentsVersions) {
-          return models.DeploymentsVersions.create({
-            current_package_id: 0,
-            deployment_id: deploymentId,
-            app_version: appVersion
-          },{transaction: t});
-        }
-        return deploymentsVersions;
-      })
+      return self.createDeploymentsVersionIfNotExist(deploymentId, appVersion, t)
       .then((deploymentsVersions) => {
         return models.Packages.create({
           deployment_version_id: deploymentsVersions.id,
@@ -216,6 +207,7 @@ proto.generateOneDiffPackage = function (workDirectoryPath, packageId, dataCente
       .then((data) => {
         return security.qetag(data.path)
         .then((diffHash) => {
+          log.debug('diff');
           return common.uploadFileToStorage(diffHash, fileName)
           .then(() => {
             var stats = fs.statSync(fileName);
@@ -303,39 +295,50 @@ proto.releasePackage = function (deploymentId, packageInfo, fileType, filePath,
       if (fileType == "application/zip") {
         return common.unzipFile(filePath, directoryPath)
       } else {
+        log.debug(`上传的文件格式不对`);
         throw new AppError.AppError("上传的文件格式不对");
       }
     })
   ])
   .spread((blobHash) => {
-    return security.isAndroidPackage(directoryPath)
+    return security.uploadPackageType(directoryPath)
     .then((type) => {
       if (type === 1) {
         //android
         if (pubType == 'ios' ) {
-          throw new AppError.AppError("it must be publish it by ios type");
+          var e = new AppError.AppError("it must be publish it by ios type");
+          log.debug(e);
+          throw e;
         }
       } else if (type === 2) {
         //ios
         if (pubType == 'android'){
-          throw new AppError.AppError("it must be publish it by android type");
+          var e = new AppError.AppError("it must be publish it by android type");
+          log.debug(e);
+          throw e;
         }
       } else {
         //不验证
+        log.debug(`Unknown package type`);
       }
-    })
-    .then(() => blobHash)
+      return blobHash;
+    });
   })
   .then((blobHash) => {
     var dataCenterManager = require('./datacenter-manager')();
     return dataCenterManager.storePackage(directoryPath)
     .then((dataCenter) => {
       var packageHash = dataCenter.packageHash;
       var manifestFile = dataCenter.manifestFilePath;
-      return self.existPackageHashAndCreateVersions(deploymentId, appVersion, packageHash)
+      return self.createDeploymentsVersionIfNotExist(deploymentId, appVersion)
+      .then((deploymentsVersions) => {
+        return self.isMatchPackageHash(deploymentsVersions.get('current_package_id'), packageHash);
+      })
       .then((isExist) => {
         if (isExist){
-          throw new AppError.AppError("The uploaded package is identical to the contents of the specified deployment's current release.");
+          var e = new AppError.AppError("The uploaded package is identical to the contents of the specified deployment's current release.");
+          log.debug(e.message);
+          throw e;
         }
         return security.qetag(manifestFile);
       })
@@ -345,7 +348,7 @@ proto.releasePackage = function (deploymentId, packageInfo, fileType, filePath,
           common.uploadFileToStorage(blobHash, filePath)
         ])
         .then(() => [packageHash, manifestHash, blobHash]);
-      });
+      })
     });
   })
   .spread((packageHash, manifestHash, blobHash) => {
@@ -411,7 +414,10 @@ proto.promotePackage = function (sourceDeploymentId, destDeploymentId, promoteUi
         if (!packages) {
           throw new AppError.AppError('does not exist packages.');
         }
-        return self.existPackageHashAndCreateVersions(destDeploymentId, deploymentsVersions.app_version, packages.package_hash)
+        return self.createDeploymentsVersionIfNotExist(destDeploymentId, deploymentsVersions.app_version)
+        .then((deploymentsVersions) => {
+          return self.isMatchPackageHash(deploymentsVersions.get('current_package_id'), packages.package_hash);
+        })
         .then((isExist) => {
           if (isExist){
             throw new AppError.AppError("The uploaded package is identical to the contents of the specified deployment's current release.");

core/utils/common.js

@@ -45,8 +45,10 @@ common.move = function (sourceDst, targertDst) {
   return new Promise((resolve, reject) => {
     fsextra.move(sourceDst, targertDst, {clobber: true, limit: 16}, function (err) {
       if (err) {
+        log.error(err);
         reject(err);
       } else {
+        log.debug(`move success sourceDst:${sourceDst} targertDst:${targertDst}`);
         resolve();
       }
     });
@@ -57,8 +59,10 @@ common.deleteFolder = function (folderPath) {
   return new Promise((resolve, reject) => {
     fsextra.remove(folderPath, function (err) {
       if (err) {
+        log.error(err);
         reject(err);
       }else {
+        log.debug(`deleteFolder delete ${folderPath} success.`);
         resolve(null);
       }
     });
@@ -135,23 +139,41 @@ common.uploadFileToLocal = function (key, filePath) {
     if (!storageDir) {
       throw new AppError.AppError('please set config local storageDir');
     }
-    if (!fs.existsSync(storageDir)) {
-      throw new AppError.AppError(`please create dir ${storageDir}`);
+    try {
+      log.debug(`uploadFileToLocal check directory ${storageDir} fs.R_OK`);
+      fs.accessSync(storageDir, fs.W_OK);
+      log.debug(`uploadFileToLocal directory ${storageDir} fs.R_OK is ok`);
+    } catch (e) {
+      log.error(e);
+      throw new AppError.AppError(e.message);
+    }
+    if (fs.existsSync(`${storageDir}/${key}`)) {
+      return resolve(key);
     }
-    fs.accessSync(storageDir, fs.W_OK);
     var stats = fs.statSync(storageDir);
     if (!stats.isDirectory()) {
-      throw new AppError.AppError(`${storageDir} must be directory`);
+      var e = new AppError.AppError(`${storageDir} must be directory`);
+      log.error(e);
+      throw e;
+    }
+    try {
+     fs.accessSync(filePath, fs.R_OK);
+    } catch (e) {
+      log.error(e);
+      throw new AppError.AppError(e.message);
     }
-    fs.accessSync(filePath, fs.R_OK);
     stats = fs.statSync(filePath);
     if (!stats.isFile()) {
-      throw new AppError.AppError(`${filePath} must be file`);
+      var e = new AppError.AppError(`${filePath} must be file`);
+      log.debug(e);
+      throw e;
     }
-    fsextra.copy(filePath, `${storageDir}/${key}`, {clobber: true, limit: 16}, (err) => {
+    fsextra.copy(filePath, `${storageDir}/${key}`,(err) => {
       if (err) {
-        return reject(err);
+        log.error(new AppError.AppError(err.message));
+        return reject(new AppError.AppError(err.message));
       }
+      log.debug(`uploadFileToLocal copy file ${key} success.`);
       resolve(key);
     });
   });