@eui/tools 5.3.62 → 5.3.64

package/scripts/csdr/metadata/package.js

@@ -328,6 +328,44 @@ const storeBuildMetadata = (pkg, pkgVersion, pkgMetadata, envTarget) => {
 }
 
 
+
+module.exports.storeMetadataBackend = (
+  pkg, pkgVersion, pkgMetadata, isMaster, duration, envTarget
+) => {
+
+tools.logTitle('Storing Backend metadata...');
+
+return Promise.resolve()
+
+  .then(() => {
+    return innerPackageVersions.storeMetadata(pkg, pkgVersion, {}, duration, envTarget);
+  })
+
+  .then(() => {
+    if (isMaster) {
+      return storeBuildMetadata(pkg, pkgVersion, pkgMetadata, envTarget);
+    }
+  })
+
+  .then(() => {
+    if (isMaster) {
+      return storePipelineMetadata(pkgMetadata);
+    }
+  })
+
+  .then(() => {
+    tools.logSuccess();
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
+
+
+
 const storePipelineMetadata = (pkgMetadata) => {
   return Promise.resolve()
     .then(() => {

package/scripts/csdr/release/package/build-pr-scan.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// UTILS
+const utils = require('../../../utils');
+
+// CSDR RELATED
+const configUtils = require('../../config/config-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+const innerUi = require('./ui');
+
+
+module.exports.run = () => {
+
+    // fetching package from config based on default arg
+    const pkg = configUtils.packages.getPackage();
+
+    // checking if the package can be retrieved from args
+    if (!pkg.name) {
+      utils.tools.logError('ERROR : "package" NOT PROVIDED as argument !!!');
+      process.exit(1);
+    }
+
+    if (pkg.remote) {
+      utils.tools.logWarning('Remote UI package - skipping...');
+      process.exit(1);
+    }
+
+    return Promise.resolve()
+      // LOGGING CURRENT eUI TOOLS VERSION
+      .then(() => {
+        utils.tools.logVersion();
+      })
+
+      // FOR UI and REMOTES clone metadata repositories
+      .then(() => {
+        return innerCommon.cloneMetadataReposCentral();
+      })
+
+      // INSTALL dependencies by type
+      .then(() => {
+        return innerUi.installOnly(pkg);
+      })
+
+      // BUILD PACKAGE
+      .then(() => {
+        return utils.buildPackage.build(pkg);
+      })
+
+      .catch((e) => {
+        console.log(e);
+        process.exit(1);
+      })
+}

package/scripts/csdr/release/package/common.js

@@ -144,6 +144,19 @@ module.exports.cloneMetadataRepos = () => {
 }
 
 
+module.exports.cloneMetadataReposCentral = () => {
+  utils.tools.logBanner('CLONE CENTRAL METADATA REPO');
+
+  return Promise.resolve()
+  .then(() => {
+    // cloning metadata repo as further installation is based on historical builds from the past
+    return metadataUtils.common.cloneMetadataRepo(true);
+  })
+  .catch((e) => {
+    throw e;
+  })
+}
+
 
 module.exports.preReleaseChecks = (pkg) => {
   utils.tools.logBanner('PRE-RELEASE checks');
@@ -468,6 +481,28 @@ module.exports.storeMetadata = (pkg, version, pkgMetadata, pkgCompositeDeps, dur
 }
 
 
+
+module.exports.storeMetadataBackend = (pkg, version, pkgMetadata, duration, envTarget) => {
+  utils.tools.logBanner('STORE BACKEND METADATA');
+
+  const branches = this.getBranches();
+
+  return Promise.resolve()
+  .then(() => {
+    return metadataUtils.package.storeMetadataBackend(
+      pkg, version, pkgMetadata,
+      branches.isMaster,
+      duration,
+      envTarget
+    );
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
 module.exports.generateDiffReport = (pkg, newVersion) => {
   utils.tools.logBanner('GENERATE DIFF REPORT');
 

package/scripts/csdr/release/package/release-backend.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// GLOBAL
+const path = require('path');
+
+// UTILS
+const utils = require('../../../utils');
+
+// CSDR RELATED
+const configUtils = require('../../config/config-utils');
+const metadataUtils = require('../../metadata/metadata-utils');
+
+// INNER MODULES
+const innerCommon = require('./common');
+
+
+module.exports.run = () => {
+
+    // fetching package from config based on default arg
+    const pkg = configUtils.packages.getPackage();
+
+    // checking if the package can be retrieved from args
+    if (!pkg.name) {
+      utils.tools.logError('ERROR : "package" NOT PROVIDED as argument !!!');
+      process.exit(1);
+    }
+
+    // Get branches flags
+    const branches = innerCommon.getBranches();
+
+    // Get envTarget (used by remotes)
+    const envTarget = innerCommon.getEnvTarget();
+
+    // Get compositeType (used by remotes)
+    const compositeType = innerCommon.getCompositeType();
+
+
+    // local saved vars
+    var newVersion, pkgMetadata, pkgCompositeDeps;
+
+
+    return Promise.resolve()
+      // LOGGING CURRENT eUI TOOLS VERSION
+      .then(() => {
+        utils.tools.logVersion();
+      })
+
+      // RELEASE PACKAGE START
+      .then(() => {
+        return innerCommon.init(pkg);
+      })
+
+      // FETCHING COMMITS METADATA
+      .then(() => {
+        return metadataUtils.commit.getMetadata(pkg);
+      })
+      .then((metadata) => {
+        pkgMetadata = metadata;
+      })
+
+      // COMMIT METADATA CHECKS
+      .then(() => {
+        return innerCommon.commitMetadataChecks(pkg);
+      })
+      .then((metadata) => {
+        pkgMetadata = metadata;
+      })
+
+
+      // EXECUTING PRE BUILD SCRIPT IF AVAILABLE
+      .then(() => {
+        return innerCommon.preBuild(pkg);
+      })
+
+
+      // BUILD PACKAGE
+      .then(() => {
+        return utils.buildPackage.build(pkg, branches.isMaster);
+      })
+
+
+      // EXECUTING SONAR ANALYSIS
+      .then(() => {
+        return utils.sonar.run(pkg, branches.isMaster);
+      })
+
+
+      // GENERATE and UPDATE new version
+      .then(() => {
+        return innerCommon.updateVersion(pkg, pkgMetadata, envTarget);
+      })
+      .then((version) => {
+        // storing version for later use
+        newVersion = version;
+      })
+
+
+      // GENERATE CHANGELOG
+      .then(() => {
+        return innerCommon.generateChangelog(pkg, newVersion, pkgMetadata);
+      })
+
+
+      // EXECUTING GLOBAL POST BUILD
+      .then(() => {
+        return innerCommon.postBuild(pkg, newVersion);
+      })
+
+
+      // PUBLISH PACKAGE
+      .then(() => {
+        return utils.publish.publish(pkg);
+      })
+
+
+      // EXECUTING POST PUBLISH SCRIPT IF AVAILABLE
+      .then(() => {
+        return utils.publish.postPublish(pkg);
+      })
+
+
+      // STORING CENTRALIZED METADATA
+      .then(() => {
+        // get run duration
+        const duration = utils.pipeline.getTimerDuration();
+        return innerCommon.storeMetadataBackend(pkg, newVersion, pkgMetadata, duration, envTarget);
+      })
+
+
+      // GIT OPERATIONS
+      .then(() => {
+        return innerCommon.runGitOperations(pkg, newVersion);
+      })
+
+
+      // EXPORT ADDITIONAL PIPELINE VARIABLES
+      .then(() => {
+        return innerCommon.exportPipelineVariables(pkg, compositeType);
+      })
+
+      // SEND SUCCESS NOTIFICATION
+      .then(() => {
+        return innerCommon.sendSuccessNotification(pkg, newVersion, pkgMetadata)
+          .then(() => {
+            innerCommon.close(pkg);
+          });
+      })
+
+      .catch((e) => {
+        return innerCommon.sendErrorNotification(pkg, e, pkgMetadata)
+          .then(() => {
+            innerCommon.close(pkg);
+            process.exit(1);
+          });
+      })
+}

package/scripts/csdr/release/package/ui.js

@@ -45,6 +45,27 @@ module.exports.install = (pkg, isMaster) => {
 }
 
 
+module.exports.installOnly = (pkg) => {
+  tools.logBanner('INSTALL');
+
+  return Promise.resolve()
+
+  // FETCHING CURRENT PACKAGES & INSTALL
+  .then(() => {
+    // fetch related project if passed as arguments
+    const prj = configUtils.projects.getProject();
+
+    // install the dependencies for current package build
+    return installUtils.buildPackage.installPackage(prj, pkg, false);
+  })
+
+  .catch((e) => {
+    throw e;
+  })
+}
+
+
+
 const checkDeps = (pkg) => {
   tools.logTitle('Checking package internal dependencies');
 

package/scripts/index.js

@@ -126,8 +126,10 @@ module.exports.metadataStats = require('./csdr/metadata/stats');
 module.exports.realeaseApp = require('./csdr/release/app/release-app');
 module.exports.releasePackageCommon = require('./csdr/release/package/common');
 module.exports.releasePackage = require('./csdr/release/package/release-package');
+module.exports.releaseBackend = require('./csdr/release/package/release-backend');
 module.exports.releasePackageRemote = require('./csdr/release/package/remote');
 module.exports.releasePackageUi = require('./csdr/release/package/ui');
+module.exports.buildPrScan = require('./csdr/release/package/build-pr-scan');
 
 // csdr - sync
 module.exports.syncUtils = require('./csdr/sync/sync-utils');