@docupace/pipeline 1.0.7-beta.2 → 1.0.8-6.xray

package/src/next/apache.js

@@ -0,0 +1,81 @@
+import fs from 'fs-extra';
+import { $ } from 'zx';
+
+function log(msg) {
+  console.log(`[*] ${msg}`);
+}
+
+export async function addApacheSite() {
+  if (
+    !process.env.ENVIRONMENT ||
+    !['dev', 'qa', 'uat', 'stage', 'www3'].includes(process.env.ENVIRONMENT)
+  ) {
+    log('Error: wront ENVIRONMENT');
+    process.exit(1);
+  }
+  if (!process.env.SITE) {
+    log('Error: SITE cannot be empty.');
+    process.exit(1);
+  }
+
+  const apacheEnvHostMap = {
+    dev: {
+      host1: 'dev-apalb01a.corp.docupace.com',
+      host2: 'dev-apalb01b.corp.docupace.com',
+      repo: 'iis-preprod',
+    },
+    qa: {
+      host1: 'qa-apalb01a.corp.docupace.com',
+      host2: 'qa-apalb01b.corp.docupace.com',
+      repo: 'iis-preprod',
+    },
+    uat: {
+      host1: 'uat-apalb01a.edc.docupace.internal',
+      host2: 'uat-apalb01b.edc.docupace.internal',
+      repo: 'iis-www2',
+    },
+    stage: {
+      host1: 'stg-apalb01a.edc.docupace.internal',
+      host2: 'stg-apalb01b.edc.docupace.internal',
+      repo: 'iis-www2',
+    },
+    www3: {
+      host1: 'prd-apalb05a.edc.docupace.internal',
+      host2: 'prd-apalb05b.edc.docupace.internal',
+      repo: 'iis-www2',
+    },
+  };
+
+  // Save private key from base64
+  const haproxyPrivateKey = process.env.HAPROXY_PRIVATE_KEY;
+  if (!haproxyPrivateKey) {
+    log('Error: HAPROXY_PRIVATE_KEY not set.');
+    process.exit(1);
+  }
+
+  await fs.writeFile('private.key', Buffer.from(haproxyPrivateKey, 'base64'));
+  await fs.chmod('private.key', 0o600);
+
+  console.log('Running command');
+  const sshCmd = (server, script) =>
+    $`ssh -i private.key -o StrictHostKeyChecking=no root@${server} ${script}`;
+
+  // The script is run twice in the Bash version
+  await sshCmd(
+    apacheEnvHostMap[process.env.ENVIRONMENT].host1,
+    `/root/tomcat_repo_sync.sh`,
+  );
+  await sshCmd(
+    apacheEnvHostMap[process.env.ENVIRONMENT].host1,
+    `/root/repo/${apacheEnvHostMap[process.env.ENVIRONMENT].repo}/scripts/addsite/add_core_site.sh ${process.env.ENVIRONMENT} ${process.env.SITE}`,
+  );
+
+  await sshCmd(
+    apacheEnvHostMap[process.env.ENVIRONMENT].host2,
+    `/root/tomcat_repo_sync.sh`,
+  );
+  await sshCmd(
+    apacheEnvHostMap[process.env.ENVIRONMENT].host2,
+    `/root/repo/${apacheEnvHostMap[process.env.ENVIRONMENT].repo}/scripts/addsite/add_core_site.sh ${process.env.ENVIRONMENT} ${process.env.SITE}`,
+  );
+}

package/src/next/cli.js

@@ -4,19 +4,27 @@ import { Command } from 'commander';
 import { pull } from './pull.js';
 import { sonar } from './sonar.js';
 import { publish } from './publish.js';
-import { deployFromSite } from './deploy.js';
-import { deployTemplate } from './deploy.js';
-import { copy } from './copy.js';
+import {
+  deployAppWithTag,
+  deployFromSite,
+  deployTemplate,
+  getDefaultDeploySite,
+  getDeployTag,
+} from './deploy.js';
+import { copy2 } from './copy.js';
+import { vaultAddSiteData } from './vault.js';
+import { addApacheSite } from './apache.js';
+import { haproxySync } from './haproxy.js';
+import { connectClone } from './connect.js';
 import dotenv from 'dotenv';
+import { $ } from 'zx';
+import { deployConnect, deployCore } from './jenkins.js';
+import { runPipeline } from './pipline.js';
 
 dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
 
 const program = new Command();
 
-// GIT SHA computation
-import { $ } from 'zx';
-import {deployConnect, deployCore} from './jenkins.js';
-import { runPipeline } from './pipline.js';
 const GIT_SHA = (await $`git log --pretty=format:'%h' -n 1`).stdout.trim();
 
 program
@@ -33,6 +41,40 @@ program
     await sonar(GIT_SHA);
   });
 
+program
+  .command('addApacheSite')
+  .description('Add site to apache')
+  .action(async () => {
+    await addApacheSite();
+  });
+
+program
+  .command('connectClone')
+  .description('Clone connect site')
+  .action(async () => {
+    await connectClone();
+  });
+
+program
+  .command('haproxySync')
+  .description('Sync haproxy config')
+  .action(async () => {
+    await haproxySync();
+  });
+
+program
+  .command('vaultAddSiteData')
+  .description('Add m2m auth0 data to vault')
+  .requiredOption('-s, --site-name <siteName>', 'Site name')
+  .requiredOption(
+    '-p, --site-config-remote-path <siteConfigRemotePath>',
+    'Site Config Remote Path',
+  )
+  .action(async (options) => {
+    const { siteName, siteConfigRemotePath } = options;
+    await vaultAddSiteData(siteName, siteConfigRemotePath);
+  });
+
 program
   .command('publish')
   .description('Publish a Docker image')
@@ -47,17 +89,70 @@ program
   .requiredOption('-t, --to-env <toEnv>', 'Target environment')
   .requiredOption('-F, --from-site <fromSite>', 'Source site')
   .requiredOption('-T, --to-site <toSite>', 'Target site')
+  .option('-j, --jira-ticket [jiraTicket]', 'JIRA ticket (optional)')
   .option('-c, --deploy-core <deployCore>', 'Deploy Core', 'false')
+  .option('-C, --deploy-connect <deployConnect>', 'Deploy Connect', 'false')
   .action(async (options) => {
-    const { fromEnv, fromSite, toEnv, toSite, deployCore } = options;
-    await deployFromSite(fromEnv, fromSite, toEnv, toSite, deployCore);
+    const {
+      fromEnv,
+      fromSite,
+      toEnv,
+      toSite,
+      deployCore,
+      deployConnect,
+      jiraTicket,
+    } = options;
+    await deployFromSite(
+      fromEnv,
+      fromSite,
+      toEnv,
+      toSite,
+      deployCore,
+      deployConnect,
+      jiraTicket,
+    );
   });
 
 program
-  .command('deployTemplate <site>')
+  .command('deploy-template [tagPrefix]')
+  .description('Deploy an standard configuration for configured sites')
+  .action(async (tagPrefix) => {
+    const deployTag = await getDeployTag(tagPrefix);
+    const sites = await getDefaultDeploySite(deployTag);
+    for (const { env, site } of sites) {
+      await deployTemplate(env, site, deployTag);
+    }
+  });
+
+program
+  .command('deploy-site-config <env> <site> [tagPrefix]')
+  .description('Deploy site configuration for a specific site')
+  .action(async (env, site, tagPrefix) => {
+    const deployTag = await getDeployTag(tagPrefix);
+    await deployTemplate(env, site, deployTag, 'siteConfigRemoteBranch');
+  });
+
+program
+  .command('deploy-app <application>')
   .description('Deploy an application for a specific site')
-  .action(async (site) => {
-    await deployTemplate(site);
+  .action(async (application) => {
+    const deployTag = await getDeployTag();
+    const sites = await getDefaultDeploySite(deployTag);
+    for (const { env, site } of sites) {
+      await deployAppWithTag(application, env, site, deployTag);
+    }
+  });
+
+program
+  .command('deploy-mono-app <tag> <application>')
+  .description('Deploy an mono application for a specific site')
+  .action(async (tag, application) => {
+    const deployTag = await getDeployTag(tag);
+    const version = 'v' + deployTag.split('@')[1];
+    const sites = await getDefaultDeploySite(version);
+    for (const { env, site } of sites) {
+      await deployAppWithTag(application, env, site, version);
+    }
   });
 
 program
@@ -95,13 +190,14 @@ program
 program
   .command('copy')
   .description('Copy a Docker image between registries')
-  .requiredOption('-a, --application <application>', 'Application name')
+  .requiredOption('-r, --repository <repository>', 'Repostory name')
   .requiredOption('-f, --from-env <fromEnv>', 'Source environment')
   .requiredOption('-t, --to-env <toEnv>', 'Target environment')
   .requiredOption('-g, --tag <tag>', 'Image tag')
+  .requiredOption('-a, --application <application>', 'Application name')
   .action(async (options) => {
-    const { application, fromEnv, toEnv, tag } = options;
-    await copy(application, fromEnv, toEnv, tag);
+    const { repository, fromEnv, toEnv, tag, application } = options;
+    await copy2(repository, fromEnv, toEnv, tag, application);
   });
 
 program

package/src/next/config.js

@@ -1,41 +1,86 @@
+import semver from 'semver';
+
 export const environments = ['dev', 'qa', 'uat', 'stage', 'prod'];
 
+const UI_MONO_VERSION = '1.4.0-alpha.0';
+
 export const environmentConfig = {
   dev: {
     newUrl: (site) => `https://${site}.dev.dpai.tech`,
     oldUrl: (site) => `https://www.dev.docupaceinc.com/${site}`,
+    docupaceHost: () => 'www.dev.docupaceinc.com',
+    ccUrl: (site) => `https://${site}-cc.dev.dpai.tech`,
   },
   qa: {
     newUrl: (site) => `https://${site}.qa.dpai.tech`,
     oldUrl: (site) => `https://www.preprod.docupaceinc.com/${site}`,
+    docupaceHost: () => 'www.preprod.docupaceinc.com',
+    ccUrl: (site) => `https://${site}-cc.qa.dpai.tech`,
   },
   uat: {
-    newUrl: (site) => `https://${site}.qa.dpai.tech`,
-    oldUrl: (site) => `https://www2.paperout.com/${site}_uat`,
+    newUrl: (site) => `https://${site}.uat.dpai.tech`,
+    oldUrl: (site) => `https://uat.paperout.com/${site}`,
+    docupaceHost: () => 'www.uat.paperout.com',
+    ccUrl: (site) => `https://${site}-cc.uat.dpai.tech`,
   },
   stage: {
     newUrl: (site) => `https://${site}.stage.dpai.tech`,
-    oldUrl: (site) => `https://www2.paperout.com/${site}_staging`,
+    oldUrl: (site) => `https://stage.paperout.com/${site}`,
+    docupaceHost: () => 'www.stage.paperout.com',
+    ccUrl: (site) => `https://${site}-cc.stage.dpai.tech`,
   },
-
   prod: {
     newUrl: (site) => `https://${site}.dpai.tech`,
-    oldUrl: (site) => `https://www2.paperout.com/${site}`,
+    oldUrl: (site) => `https://www3.paperout.com/${site}`,
+    docupaceHost: () => 'www3.paperout.com',
+    ccUrl: (site) => `https://${site}-cc.dpai.tech`,
   },
 };
 
 export const appInfo = {
   'graphql-server': {
     repositoryName: 'docupace-graphql-server',
+    imageName: 'docupace-graphql-server',
     deployAttributes: [
       'image.tag',
       'graphqlServer.siteConfigRemoteBranch',
       'graphqlServer.standardConfigRemoteBranch',
     ],
   },
+  cc: {
+    repositoryName: 'docupace-ui-main',
+    imageName: 'cc-ui-app',
+    deployAttributes: ['image.tag'],
+    getAppRevision: (config) => {
+      const version = config.image.tag.slice(1);
+      return 'cc-ui-app@' + version;
+    },
+  },
   ui: {
     repositoryName: 'docupace-ui-main',
+    imageName: 'enterprise-ui-app',
     deployAttributes: ['image.tag'],
+    getAppRevision: (config) => {
+      const tag = config.image.tag;
+      const version = tag.startsWith('v') ? tag.slice(1) : tag;
+      if (semver.gt(version, UI_MONO_VERSION)) {
+        return 'enterprise-ui-app@' + version;
+      } else {
+        return tag;
+      }
+    },
+    updateConfigFunction: (config) => {
+      if (config.image.repository.endsWith('/docupace-ui-main')) {
+        const tag = config.image.tag;
+        const version = tag.startsWith('v') ? tag.slice(1) : tag;
+        if (semver.gt(version, UI_MONO_VERSION)) {
+          const parts = config.image.repository.split('/');
+          parts[2] = 'enterprise-ui-app';
+          config.image.repository = parts.join('/');
+        }
+      }
+      return config;
+    },
   },
 };
 
@@ -65,8 +110,28 @@ export const getBitbucketInfo = () => {
 
 export const getRepUrl = (repoName) => {
   const { username, password, workspace } = getBitbucketInfo();
-  const repoUrl = `https://${username}:${password}@bitbucket.org/${workspace}/${repoName}.git`;
-  return repoUrl;
+  return `https://${username}:${password}@bitbucket.org/${workspace}/${repoName}.git`;
 };
 
 export const jfRegistryUrl = 'registry.paperout.com';
+
+export const getVaultSecretsConfigs = (site) => {
+  return {
+    commonSecretsPath: 'secret/data/common/config',
+    siteCommonSecretsPath: `secret/data/${site}/common/config`,
+    graphqlServerSecretsPath: `secret/data/${site}/graphql-server/config`,
+    uiSecretsPath: `secret/data/${site}/ui/config`,
+    ccUISecretsPath: `secret/data/${site}/ui-cc/config`,
+    awsSecretsPath: `secret/data/${site}/aws/config`,
+  };
+};
+
+export const coreSiteEnvMap = {
+  dev: 'dev',
+  qa: 'preprod',
+  stg: 'staging',
+  stage: 'staging',
+  uat: 'uat',
+  prd: 'prod',
+  prod: 'prod',
+};

package/src/next/connect.js

@@ -0,0 +1,226 @@
+import 'zx/globals'; // npm i zx
+import fs from 'fs-extra';
+import path from 'path';
+import { $ } from 'zx';
+import { getAuth0Metadata } from '../auth0/metadata.js';
+import { getVaultSecrets } from '../auth0/vault.js';
+
+process.env.COMMON_VAULT_PATH =
+  process.env.COMMON_VAULT_PATH || 'secret/data/common/config';
+process.env.VAULT_SKIP_VERIFY = process.env.VAULT_SKIP_VERIFY || 'true';
+process.env.CONNECT_DIR = process.env.CONNECT_DIR || 'connect';
+const vaultToken = process.env.VAULT_TOKEN;
+const vaultAddr = process.env.VAULT_ADDR;
+
+const connectUIEnvMap = {
+  dev: 'dev',
+  qa: 'preprod',
+  stage: 'stg',
+  uat: 'uat',
+  prod: 'prod-www3',
+};
+
+const siteSettingsEnvMap = {
+  dev: 'dev',
+  preprod: 'preprod',
+  qa: 'preprod',
+  stage: 'staging',
+  stg: 'staging',
+  uat: 'uat',
+  prd: 'prod',
+  prod: 'prod',
+  'prod-www3': 'prod',
+  'prod-las': 'prod',
+  'prod-lax': 'prod',
+  'prod-athene': 'prod',
+  'prod-staging': 'prod',
+};
+
+const idpEnvMap = {
+  dev: 'dev',
+  preprod: 'qa',
+  qa: 'qa',
+  stage: 'stage',
+  stg: 'stage',
+  uat: 'uat',
+  prd: 'prod',
+  prod: 'prod',
+  'prod-www3': 'prod',
+  'prod-las': 'prod',
+  'prod-lax': 'prod',
+  'prod-athene': 'prod',
+  'prod-staging': 'prod',
+};
+
+function log(msg) {
+  console.log(`[*] ${msg}`);
+}
+
+/* --------------------------------
+ * 1. GIT CHECKOUT
+ * -------------------------------- */
+async function gitCheckout(repository, destDir, branch = 'master') {
+  if (!(await fs.pathExists(destDir))) {
+    log(`Directory ${destDir} does not exist. Cloning repository...`);
+  } else {
+    log(`Directory ${destDir} exists. Removing it...`);
+    await fs.remove(destDir);
+    log(`Cloning ${destDir} repository...`);
+  }
+
+  const username = process.env.BITBUCKET_USERNAME;
+  const password = process.env.BITBUCKET_APP_PASSWORD;
+
+  // Construct clone command
+  const cloneUrl = `https://${username}:${password}@bitbucket.org/dp-cloud/${repository}.git`;
+
+  log(`Perform cloning`);
+  await $`git clone --branch=${branch} --depth 1 ${cloneUrl} ${destDir}`;
+}
+
+export async function connectClone() {
+  // const connectFromEnv = connectUIEnvMap[process.env.FROM_BUILD_ENVIRONMENT];
+  const connectFromEnv = process.env.FROM_BUILD_ENVIRONMENT;
+  const connectToEnv = process.env.BUILD_ENVIRONMENT;
+
+  if (!vaultToken || !vaultAddr) {
+    console.error('Error: VAULT_TOKEN and VAULT_ADDR must be set.');
+    throw new Error('VAULT_TOKEN and VAULT_ADDR must be set.');
+  }
+
+  const site = process.env.BUILD_SITE;
+  if (!site) {
+    log('Error: BUILD_SITE is not set');
+    process.exit(1);
+  }
+  const siteCommonVaultPath = `secret/data/${site}/common/config`;
+
+  // 2) getVaultSecrets
+  const secretsJson = await getVaultSecrets(siteCommonVaultPath);
+  if (!secretsJson.AUTH0_CLIENT_ID) {
+    log('Failed to retrieve secret data.');
+    process.exit(1);
+  }
+  const siteCommonSecrets = secretsJson;
+
+  // 3) Export secrets as environment variables
+  process.env.AUTH0_CLIENT_ID = siteCommonSecrets.AUTH0_CLIENT_ID;
+  process.env.AUTH0_CLIENT_SECRET = siteCommonSecrets.AUTH0_CLIENT_SECRET;
+
+  process.env.AUTH0_REGION_DOMAIN = 'us.auth0.com';
+
+  log(`BUILD_ENVIRONMENT: ${connectToEnv}`);
+  log(`BUILD_SITE: ${process.env.BUILD_SITE}`);
+  log(`AUTH0_SUBDOMAIN: ${process.env.AUTH0_SUBDOMAIN}`);
+  log(`AUTH0_REGION_DOMAIN: ${process.env.AUTH0_REGION_DOMAIN}`);
+  log(`AUTH0_CLIENT_ID: ${process.env.AUTH0_CLIENT_ID}`);
+
+  process.env.AUTH0_DOMAIN = `docupace-${idpEnvMap[process.env.BUILD_ENVIRONMENT]}-${process.env.BUILD_SITE}.${process.env.AUTH0_REGION_DOMAIN}`;
+
+  const projectRoot = process.cwd();
+  // 4) Clone 'connect-deploy' into CONNECT_DIR
+
+  await gitCheckout('connect-deploy', process.env.CONNECT_DIR);
+
+  await gitCheckout(
+    `${siteSettingsEnvMap[connectToEnv]}-site-settings`,
+    `${process.env.CONNECT_DIR}/${siteSettingsEnvMap[connectToEnv]}-site-settings`,
+  );
+
+  // 5) Create site clone (emulating the dock.sh call)
+  const cloneFrom = path.join(
+    projectRoot,
+    process.env.CONNECT_DIR,
+    `envs`,
+    `${connectFromEnv}/${process.env.FROM_BUILD_SITE}`,
+  );
+  const cloneTo = path.join(
+    projectRoot,
+    process.env.CONNECT_DIR,
+    `envs`,
+    `${connectToEnv}/${process.env.BUILD_SITE}`,
+  );
+
+  if (!(await fs.pathExists(cloneFrom))) {
+    log('Clone template directory not found:');
+    process.exit(1);
+  }
+
+  if (!(await fs.pathExists(cloneTo))) {
+    log('New site does not exist. Performing cloning...');
+
+    process.env.IMAGE_VERSION =
+      await $`cd ${cloneFrom} && grep -E '^IMAGE_VERSION=' dock.sh | cut -f2 -d=`;
+    log(`Image version: ${process.env.IMAGE_VERSION}`);
+    //await $`cd ${cloneFrom} && bash dock.sh clone ${process.env.BUILD_ENVIRONMENT} ${process.env.BUILD_SITE} ${process.env.IMAGE_VERSION}`;
+    await (async () => {
+      try {
+        // Execute the shell command
+        const result =
+          await $`cd ${cloneFrom} && bash dock.sh clone ${connectToEnv} ${process.env.BUILD_SITE} ${process.env.IMAGE_VERSION}`;
+        await $`cd ${cloneTo} && git checkout master && git pull --ff-only`;
+        await $`cd ${cloneTo} && git remote -v`;
+        await $`cd ${cloneTo} && git branch`;
+        await $`cd ${cloneTo} && git status`;
+        await $`cd ${cloneTo} && git add . ../sites.sh`;
+
+        console.log('Command succeeded:');
+        console.log('stdout:', result.stdout); // Standard output
+        console.log('stderr:', result.stderr); // Standard error
+      } catch (error) {
+        console.error('Command failed:');
+        console.error('Exit Code:', error._code); // Exit code of the command
+        console.error('Signal:', error._signal); // Signal that caused termination (if any)
+        console.error('stdout:', error._stdout); // Standard output
+        console.error('stderr:', error._stderr); // Standard error
+      }
+    })();
+  } else {
+    log('Site already exists. Continuing Auth0 setup...');
+  }
+
+  // await (async () => {
+  //   try {
+  //     // Execute the shell command
+  //     //await getAuth0Metadata(process.env.BUILD_SITE, connectToEnv);
+  //     const result = await $`cd ${cloneTo} && bash dock.sh getAuth0Metadata`;
+  //     console.log('Command succeeded:');
+  //     console.log('stdout:', result.stdout); // Standard output
+  //     console.log('stderr:', result.stderr); // Standard error
+  //   } catch (error) {
+  //     console.error('Command failed:');
+  //     console.error('Exit Code:', error._code); // Exit code of the command
+  //     console.error('Signal:', error._signal); // Signal that caused termination (if any)
+  //     console.error('stdout:', error._stdout); // Standard output
+  //     console.error('stderr:', error._stderr); // Standard error
+  //   }
+  // })();
+
+  // 7) Check conf files, print logs
+  // await $`grep "auth0" ${path.join(cloneTo, 'conf/application.conf')}`;
+  // await $`ls -all ${path.join(cloneTo, 'conf')}`;
+  // await $`ls -all ${path.join(cloneTo, 'conf/saml')}`;
+  // await $`cat ${path.join(cloneTo, 'conf/saml/auth0.xml')}`;
+
+  // 8) Git add, commit, push
+  // await $`cd ${cloneTo} && git add ./conf/application.conf ./conf/saml/auth0.xml`;
+  //await $`cd ${cloneTo} && git add ./conf/application.conf`;
+  //await $`cd ${cloneTo} && git status`;
+
+  const numChanges = (await $`cd ${cloneTo} && git diff-index HEAD`).stdout
+    .split('\n')
+    .filter(Boolean).length;
+
+  if (numChanges > 0) {
+    const jiraTicket = process.env.JIRA_TICKET || 'NO_JIRA';
+    const message = `${jiraTicket} usdoc-s-builui job download_auth0_metadata for ${connectToEnv}/${process.env.BUILD_SITE}`;
+    log('About to commit changes to git');
+    await $`cd ${cloneTo} && git commit -m ${message}`;
+    await $`cd ${cloneTo} && git push -u origin master`;
+    //await getAuth0Metadata(process.env.BUILD_SITE, connectToEnv);
+  } else {
+    log(
+      'No changes have been made. The site likely already has the correct configuration.',
+    );
+  }
+}

package/src/next/copy.js

@@ -11,7 +11,38 @@ export async function copy(application, fromEnv, toEnv, tag) {
   const repositoryName = appInfo[application].repositoryName;
   const fromRegistry = `${jfRegistryUrl}/${repositoryName}-${fromEnv}-docker-local`;
   const toRegistry = `${jfRegistryUrl}/${repositoryName}-${toEnv}-docker-local`;
-  const imageName = `${repositoryName}:${tag}`;
+  const imageName = `${appInfo[application].imageName}:${tag}`;
+  const fromFullImageName = `${fromRegistry}/${imageName}`;
+  const toFullImageName = `${toRegistry}/${imageName}`;
+
+  console.log(
+    `Copying Docker image: ${fromFullImageName} -> ${toFullImageName}`,
+  );
+
+  // Login to source registry
+  await $`echo ${envInfo[fromEnv].jfrog.password} | docker login --username ${envInfo[fromEnv].jfrog.username} --password-stdin ${jfRegistryUrl}`;
+  await $`docker pull ${fromFullImageName}`;
+  await $`docker tag ${fromFullImageName} ${toFullImageName}`;
+
+  // Login to target registry
+  await $`echo ${envInfo[toEnv].jfrog.password} | docker login --username ${envInfo[toEnv].jfrog.username} --password-stdin ${jfRegistryUrl}`;
+  await $`docker push ${toFullImageName}`;
+}
+
+export async function copy2(
+  repositoryName,
+  fromEnv,
+  toEnv,
+  tag,
+  applicationName,
+) {
+  console.log(
+    `Copying repository ${repositoryName} from ${fromEnv} to ${toEnv} for tag ${tag}`,
+  );
+  const envInfo = getEnvInfo();
+  const fromRegistry = `${jfRegistryUrl}/${repositoryName}-${fromEnv}-docker-local`;
+  const toRegistry = `${jfRegistryUrl}/${repositoryName}-${toEnv}-docker-local`;
+  const imageName = `${applicationName ?? repositoryName}:${tag}`;
   const fromFullImageName = `${fromRegistry}/${imageName}`;
   const toFullImageName = `${toRegistry}/${imageName}`;