@docupace/pipeline 1.0.1 → 1.0.2-3.tes2

package/src/next/copy.js

@@ -1,27 +1,30 @@
 import { $ } from 'zx';
-
+import { appInfo, getEnvInfo, jfRegistryUrl } from './config.js';
 
 /*
     TARGET_ENV
     PUBLISH_TAG
     REPOSITORY_NAME
  */
-export async function copy() {
-    const JF_REGISTRY_URL = 'registry.paperout.com';
-    const SOURCE_REGISTRY = `${JF_REGISTRY_URL}/${process.env.REPOSITORY_NAME}-dev-docker-local`;
-    const TARGET_REGISTRY = `${JF_REGISTRY_URL}/${process.env.REPOSITORY_NAME}-${process.env.TARGET_ENV}-docker-local`;
-    const IMAGE_NAME = `${process.env.REPOSITORY_NAME}:${process.env.PUBLISH_TAG}`;
-    const SOURCE_FULL_IMAGE_NAME = `${SOURCE_REGISTRY}/${IMAGE_NAME}`;
-    const TARGET_FULL_IMAGE_NAME = `${TARGET_REGISTRY}/${IMAGE_NAME}`;
+export async function copy(application, fromEnv, toEnv, tag) {
+  const envInfo = getEnvInfo();
+  const repositoryName = appInfo[application].repositoryName;
+  const fromRegistry = `${jfRegistryUrl}/${repositoryName}-${fromEnv}-docker-local`;
+  const toRegistry = `${jfRegistryUrl}/${repositoryName}-${toEnv}-docker-local`;
+  const imageName = `${repositoryName}:${tag}`;
+  const fromFullImageName = `${fromRegistry}/${imageName}`;
+  const toFullImageName = `${toRegistry}/${imageName}`;
 
-    console.log(`Copying Docker image: ${SOURCE_FULL_IMAGE_NAME} -> ${TARGET_FULL_IMAGE_NAME}`);
+  console.log(
+    `Copying Docker image: ${fromFullImageName} -> ${toFullImageName}`,
+  );
 
-    // Login to source registry
-    await $`echo ${process.env.JF_REGISTRY_PASSWORD_DEV} | docker login --username ${process.env.JF_REGISTRY_USER_DEV} --password-stdin ${JF_REGISTRY_URL}`;
-    await $`docker pull ${SOURCE_FULL_IMAGE_NAME}`;
-    await $`docker tag ${SOURCE_FULL_IMAGE_NAME} ${TARGET_FULL_IMAGE_NAME}`;
+  // 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 ${process.env.JF_REGISTRY_PASSWORD_QA} | docker login --username ${process.env.JF_REGISTRY_USER_QA} --password-stdin ${JF_REGISTRY_URL}`;
-    await $`docker push ${TARGET_FULL_IMAGE_NAME}`;
+  // Login to target registry
+  await $`echo ${envInfo[toEnv].jfrog.password} | docker login --username ${envInfo[toEnv].jfrog.username} --password-stdin ${jfRegistryUrl}`;
+  await $`docker push ${toFullImageName}`;
 }

package/src/next/deploy.js

@@ -2,10 +2,11 @@ import fs from 'fs';
 import path from 'path';
 import yaml from 'js-yaml';
 import { $ } from 'zx';
-
-const REPO_NAME = 'gitops-dev';
-const REPO_URL = `https://x-token-auth:${process.env.GITOPS_DEV_REP_TOKEN}@bitbucket.org/dp-cloud/${REPO_NAME}.git`;
-const GITOPS_BRANCH = 'master';
+import lodash from 'lodash';
+import { appInfo, environmentConfig, getRepUrl } from './config.js';
+import { copy } from './copy.js';
+import axios from 'axios';
+import { deployCore } from './jenkins.js';
 
 /**
  * Clone the repository, read the YAML file, and return the parsed data and file paths.
@@ -13,24 +14,106 @@ const GITOPS_BRANCH = 'master';
  * @param {string} site - The site name.
  * @returns {object} - The repository path, file path, and YAML data.
  */
-export async function readDeployConfig(application, site) {
-    const repoPath = path.join(process.cwd(), REPO_NAME);
-    const deployConfigFilePath = path.join(repoPath, `dp/${site}/${application}.values.yaml`);
 
-    console.log(`Cloning repository: ${REPO_NAME}`);
-    await $`git clone ${REPO_URL}`;
-    console.log(`Repository cloned to: ${repoPath}`);
+function getRepoLocalPath(env) {
+  const repoName = `gitops-${env}`;
+  const repoPath = path.join(process.cwd(), repoName);
+  return { repoPath, repoName };
+}
 
-    let deployConfig;
-    try {
-        deployConfig = yaml.load(fs.readFileSync(deployConfigFilePath, 'utf8'));
-        console.log(`YAML file loaded from: ${deployConfigFilePath}`);
-    } catch (error) {
-        console.error(`Error reading YAML file: ${error.message}`);
-        process.exit(1);
-    }
+function getRepoLocalPathByRepoSlug(repoSlug) {
+  const repoName = `${repoSlug}`;
+  const repoPath = path.join(process.cwd(), repoName);
+  return { repoPath, repoName };
+}
 
-    return { repoPath, deployConfigFilePath, deployConfig };
+function cleanUpRepoPath(repoPath) {
+  // Check and handle repo directory
+  if (fs.existsSync(repoPath)) {
+    console.log(`${repoPath} directory exists. Removing it...`);
+    fs.rmSync(repoPath, {
+      recursive: true,
+      force: true,
+    });
+  }
+}
+
+export async function cloneEnvRepository(env) {
+  const { repoPath, repoName } = getRepoLocalPath(env);
+  const repoUrl = getRepUrl(repoName);
+  console.log(`Cloning repository: ${repoName}`);
+  await cleanUpRepoPath(repoPath);
+  await $`git clone --depth 1 ${repoUrl}`;
+  console.log(`Repository cloned to: ${repoPath}`);
+  return repoPath;
+}
+
+export async function cloneRepository(repoSlug) {
+  const { repoPath, repoName } = getRepoLocalPathByRepoSlug(repoSlug);
+  const repoUrl = getRepUrl(repoName);
+
+  await cleanUpRepoPath(repoPath);
+
+  console.log(`Cloning repository: ${repoName}`);
+  await $`git clone --depth 1 ${repoUrl}`;
+  console.log(`Repository cloned to: ${repoPath}`);
+  return repoPath;
+}
+
+function getConfigPath(application, env, site, name) {
+  const { repoPath } = getRepoLocalPath(env);
+  const deployConfigFilePath = path.join(
+    repoPath,
+    `dp/${site}/${application}.${name}.yaml`,
+  );
+
+  return { repoPath, deployConfigFilePath };
+}
+
+function getAppTypesFromRepo(env, site) {
+  const { repoPath } = getRepoLocalPath(env);
+  const deployConfigFilePath = path.join(repoPath, `dp/${site}`);
+  console.log(deployConfigFilePath);
+  const applications = [];
+  if (fs.existsSync(deployConfigFilePath)) {
+    const files = fs.readdirSync(deployConfigFilePath);
+    files.forEach((file) => {
+      if (file.includes('.values.yaml')) {
+        const appName = file.split('.')[0];
+        applications.push(appName);
+      }
+    });
+  }
+
+  return { applications };
+}
+
+export async function readDeployConfig(application, env, site, name) {
+  const { deployConfigFilePath } = getConfigPath(application, env, site, name);
+
+  let deployConfig;
+  try {
+    deployConfig = yaml.load(fs.readFileSync(deployConfigFilePath, 'utf8'));
+    console.log(`YAML file loaded from: ${deployConfigFilePath}`);
+  } catch (error) {
+    console.error(`Error reading YAML file: ${error.message}`);
+    process.exit(1);
+  }
+
+  return { deployConfig, deployConfigFilePath };
+}
+
+export async function cloneAndReadDeployConfig(application, env, site) {
+  const repoPath = await cloneEnvRepository(env);
+
+  const { deployConfig, deployConfigFilePath } = await readDeployConfig(
+    application,
+    env,
+    site,
+    'values',
+  );
+
+  return { repoPath, deployConfigFilePath, deployConfig };
 }
 
 /**
@@ -40,15 +123,15 @@ export async function readDeployConfig(application, site) {
  * @returns {object} - The updated YAML data.
  */
 export function setTag(deployConfig, tag) {
-    if (deployConfig.image && deployConfig.image.tag) {
-        console.log(`Current image tag: ${deployConfig.image.tag}`);
-        deployConfig.image.tag = tag;
-        console.log(`Updated image tag to: ${deployConfig.image.tag}`);
-    } else {
-        console.error('No "image.tag" field found in the YAML file.');
-        process.exit(1);
-    }
-    return deployConfig;
+  if (deployConfig.image && deployConfig.image.tag) {
+    console.log(`Current image tag: ${deployConfig.image.tag}`);
+    deployConfig.image.tag = tag;
+    console.log(`Updated image tag to: ${deployConfig.image.tag}`);
+  } else {
+    console.error('No "image.tag" field found in the YAML file.');
+    process.exit(1);
+  }
+  return deployConfig;
 }
 
 /**
@@ -57,25 +140,50 @@ export function setTag(deployConfig, tag) {
  * @param {string} deployConfigFilePath - The path to the YAML file.
  * @param {object} deployConfig - The updated YAML data.
  */
-export async function writeDeployConfig(repoPath, deployConfigFilePath, deployConfig) {
-    try {
-        fs.writeFileSync(deployConfigFilePath, yaml.dump(deployConfig), 'utf8');
-        console.log(`Updated YAML file saved at: ${deployConfigFilePath}`);
-    } catch (error) {
-        console.error(`Error writing YAML file: ${error.message}`);
-        process.exit(1);
-    }
 
-    console.log('Committing changes to the repository...');
-    await $`cd ${repoPath} && git config user.email "gitops@docupace.com"`;
-    await $`cd ${repoPath} && git add ${deployConfigFilePath}`;
-    await $`cd ${repoPath} && git commit -m "Update image tag to ${deployConfig.image.tag}"`;
-    await $`cd ${repoPath} && git push origin ${GITOPS_BRANCH}`;
-    console.log('Changes pushed to the remote repository.');
-
-    console.log('Cleaning up...');
+export async function pushDeployConfig(repoPath, commitMessage) {
+  console.log('📌 Checking for updates to commit...');
+  // Check if there are any changes to commit
+  const status = (
+    await $`cd ${repoPath} && git status --porcelain`
+  ).stdout.trim();
+  if (!status) {
+    console.log('✅ No changes to commit. Exiting.');
     await $`rm -rf ${repoPath}`;
-    console.log('Cleanup complete.');
+    console.log('🧹 Cleanup complete.');
+    return;
+  }
+
+  console.log('📌 Committing changes to the repository...');
+  await $`cd ${repoPath} && git config user.email "gitops@docupace.com"`;
+  await $`cd ${repoPath} && git add .`;
+  await $`cd ${repoPath} && git commit -m ${commitMessage}`;
+  await $`cd ${repoPath} && git push`;
+  console.log('✅ Changes pushed to the remote repository.');
+
+  console.log('🧹 Cleaning up...');
+  await $`rm -rf ${repoPath}`;
+  console.log('✅ Cleanup complete.');
+}
+
+function writeDeployConfig(deployConfigFilePath, deployConfig) {
+  try {
+    fs.writeFileSync(deployConfigFilePath, yaml.dump(deployConfig), 'utf8');
+    console.log(`✅ Updated YAML file saved at: ${deployConfigFilePath}`);
+  } catch (error) {
+    console.error(`❌ Error writing YAML file: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+export async function writeAndPushDeployConfig(
+  repoPath,
+  deployConfigFilePath,
+  deployConfig,
+  commitMessage,
+) {
+  writeDeployConfig(deployConfigFilePath, deployConfig);
+  await pushDeployConfig(repoPath, commitMessage);
 }
 
 /**
@@ -85,34 +193,231 @@ export async function writeDeployConfig(repoPath, deployConfigFilePath, deployCo
  */
 
 async function getDeployTag() {
-    const gitTag = (await $`git tag --points-at HEAD | grep '^v' | head -n 1`).stdout.trim()
-    const deployTag = gitTag || `build-${process.env.BITBUCKET_BUILD_NUMBER}`;
-    return deployTag;
+  const gitTag = (
+    await $`git tag --points-at HEAD | grep '^v' | head -n 1`
+  ).stdout.trim();
+  const deployTag = gitTag || `build-${process.env.BITBUCKET_BUILD_NUMBER}`;
+  return deployTag;
 }
 
 export async function deployTemplate(site) {
-    const deployTag = await getDeployTag();
-    console.log(`Deploying standard template for site: ${site}`);
-    console.log(`Using deployment tag: ${deployTag}`);
-    const { repoPath, deployConfigFilePath, deployConfig } = await readDeployConfig('graphql-server', site);
+  const deployTag = await getDeployTag();
+  console.log(`Deploying standard template for site: ${site}`);
+  console.log(`Using deployment tag: ${deployTag}`);
+  const { repoPath, deployConfigFilePath, deployConfig } =
+    await cloneAndReadDeployConfig('graphql-server', 'dev', site);
+
+  deployConfig.graphqlServer.standardConfigRemoteBranch = deployTag;
+
+  await writeAndPushDeployConfig(
+    repoPath,
+    deployConfigFilePath,
+    deployConfig,
+    `Update template to  ${deployConfig.graphqlServer.standardConfigRemoteBranch}`,
+  );
+  console.log('Deployment completed successfully.');
+}
+
+export async function deploy(application, site) {
+  const deployTag = getDeployTag();
 
-    deployConfig.graphqlServer.standardConfigRemoteBranch = deployTag;
+  console.log(`Deploying application: ${application} for site: ${site}`);
+  console.log(`Using deployment tag: ${deployTag}`);
 
-    await writeDeployConfig(repoPath, deployConfigFilePath, deployConfig);
-    console.log('Deployment completed successfully.');
+  const { repoPath, deployConfigFilePath, deployConfig } =
+    await cloneAndReadDeployConfig(application, 'dev', site);
+  const updatedConfigData = setTag(deployConfig, deployTag);
+  await writeAndPushDeployConfig(
+    repoPath,
+    deployConfigFilePath,
+    updatedConfigData,
+    `Update image tag to ${deployConfig.image.tag}`,
+  );
 
+  console.log('Deployment completed successfully.');
 }
 
+async function getAppInfo(coreUrl) {
+  const url = `${coreUrl}/b2b/rest/v1/appinfo`;
+  return await axios.get(url);
+}
 
-export async function deploy(application, site) {
-    const deployTag = getDeployTag();
+function getBranchNameFromVersion(version) {
+  const match = version.match(/(\d+\.\d+\.[^\-]+)(?:-(\d+)-g([a-f0-9]+))?/);
+
+  if (!match) {
+    throw new Error(`Invalid version format: ${version}`);
+  }
+
+  const fullVersion = match[1]; // e.g., 24.19.19, 24.20.alpha3, etc.
+  const customBranch = match[2]; // e.g., 4, 58, or 0
+  const commitHash = match[3]; // e.g., 668edef58e, 634cf6c904, etc.
+
+  // If "alpha" is in the version or customBranch is non-zero, use the commit hash
+  if (fullVersion.includes('alpha') || (customBranch && customBranch !== '0')) {
+    return commitHash;
+  }
+
+  // Otherwise, use the full version
+  return fullVersion;
+}
+
+async function getCoreBranchName(fromEnv, fromSite) {
+  const envConfig = environmentConfig[fromEnv];
+  const oldUrl = envConfig.oldUrl(fromSite);
+  const newUrl = envConfig.newUrl(fromSite) + '/core';
+
+  let appinfo;
+  try {
+    appinfo = await getAppInfo(oldUrl);
+  } catch {
+    try {
+      appinfo = await getAppInfo(newUrl);
+    } catch {
+      throw new Error('Cannot get app info');
+    }
+  }
+
+  const coreVersion = appinfo.data.core.version;
+  const branchName = getBranchNameFromVersion(coreVersion);
+  return branchName;
+}
+
+export async function deployApp(
+  application,
+  appDetails,
+  fromEnv,
+  fromSite,
+  toEnv,
+  toSite,
+) {
+  let changesMade = false;
+  console.log(`Processing application: ${application}`);
+
+  // Read the deployment configuration for the source environment and site
+  const { deployConfig: fromDeployConfig } = await readDeployConfig(
+    application,
+    fromEnv,
+    fromSite,
+    'values',
+  );
+
+  if (fromEnv !== toEnv) {
+    await copy(application, fromEnv, toEnv, fromDeployConfig.image.tag);
+  }
 
-    console.log(`Deploying application: ${application} for site: ${site}`);
-    console.log(`Using deployment tag: ${deployTag}`);
+  // Read the deployment configuration for the target environment and site
+  const {
+    deployConfig: toDeployConfig,
+    deployConfigFilePath: toDeployConfigFilePath,
+  } = await readDeployConfig(application, toEnv, toSite, 'values');
 
-    const { repoPath, deployConfigFilePath, deployConfig } = await readDeployConfig(application, site);
-    const updatedConfigData = setTag(deployConfig, deployTag);
-    await writeDeployConfig(repoPath, deployConfigFilePath, updatedConfigData);
+  // Update target configuration using attributes specified in appInfo
+  for (const attribute of appDetails.deployAttributes) {
+    const sourceValue = lodash.get(fromDeployConfig, attribute);
+
+    if (sourceValue !== undefined) {
+      // Update the target configuration with the source value
+      lodash.set(toDeployConfig, attribute, sourceValue);
+      changesMade = true;
+    }
+  }
+
+  const {
+    deployConfig: toDeployAppConfig,
+    deployConfigFilePath: toDeployAppConfigFilePath,
+  } = await readDeployConfig(application, toEnv, toSite, 'app');
+
+  toDeployAppConfig.revision = fromDeployConfig.image.tag;
+
+  // Write updated configuration to the target YAML file
+  writeDeployConfig(toDeployConfigFilePath, toDeployConfig);
+
+  writeDeployConfig(toDeployAppConfigFilePath, toDeployAppConfig);
+  return changesMade;
+}
+
+export async function deployFromSite(
+  fromEnv,
+  fromSite,
+  toEnv,
+  toSite,
+  isDeployCore,
+) {
+  if (isDeployCore === 'true') {
+    const branchName = await getCoreBranchName(fromEnv, fromSite);
+
+    const coreEnv = toEnv == 'qa' ? 'preprod' : toEnv;
+    await deployCore(coreEnv, toSite, 'true', branchName);
+
+    // To be added back when splitting between on prem and in cloud
+    /*await runPipeline('site-deploy', 'deploy-core', 'main', {
+      ENV: toEnv,
+      SITE: toSite,
+      LIQUIBASE: 'true',
+      BRANCH: branchName,
+    });*/
+  }
+
+  // Clone repositories for source and target environments
+  const fromRepoPath = await cloneEnvRepository(fromEnv);
+  const toRepoPath =
+    toEnv === fromEnv ? fromRepoPath : await cloneEnvRepository(toEnv);
+
+  // Initialize a flag to track changes
+  let changesMade = false;
+  const applications = await getAppTypesFromRepo(fromEnv, fromSite);
+  console.log(applications);
+  // Iterate over applications in appInfo
+  let appInfoLocal = {};
+  // let appInfoLocal = Object.fromEntries(
+  //   applications
+  //     .filter((application) => appInfo[application])
+  //     .map((application) => [application, appInfo[application]]),
+  // );
+
+  for (const application of applications) {
+    if (Object.prototype.hasOwnProperty.call(appInfo, application)) {
+      appInfoLocal[application] = appInfo[application];
+    }
+  }
+
+  if (Object.keys(appInfoLocal).length === 0) {
+    const { deployConfig: toDeployAppConfig } = await readDeployConfig(
+      fromSite,
+      toEnv,
+      toSite,
+      'app',
+    );
+
+    appInfoLocal[fromSite] = {
+      repositoryName: toDeployAppConfig.repo,
+      deployAttributes: ['image.tag'],
+    };
+  }
+
+  for (const [application, appDetails] of Object.entries(appInfo)) {
+    let cm = await deployApp(
+      application,
+      appDetails,
+      fromEnv,
+      fromSite,
+      toEnv,
+      toSite,
+    );
+    if (cm) {
+      changesMade = true;
+    }
+  }
 
-    console.log('Deployment completed successfully.');
+  // Push all changes if any updates were made
+  if (changesMade) {
+    await pushDeployConfig(
+      toRepoPath,
+      `Updated deployment configurations from ${fromEnv}/${fromSite} to ${toEnv}/${toSite}`,
+    );
+    console.log('✅ All configurations updated and pushed successfully.');
+  } else {
+    console.log('✅ No changes detected. Nothing to push.');
+  }
 }

package/src/next/haproxy.js

@@ -0,0 +1,50 @@
+import { $ } from 'zx';
+
+
+export async function haproxySync() {
+    const repoPath = '/root/repo/docupace-ansible';
+    const inventory = path.join(repoPath, 'inventories/preprod/inventory');
+  
+    // Create haproxy.sh
+    const scriptContent = `
+  #!/bin/bash
+  
+  [[ ! -f ${inventory} ]] && ( echo "Alert: no inventory file: ${inventory}" ; exit 1 )
+  cd ${repoPath}
+  pwd
+  git stash
+  git pull origin master
+  git checkout master
+  git submodule update --remote
+  git submodule foreach --recursive git checkout master
+  git submodule foreach --recursive git pull origin master
+  
+  ansible-playbook -i inventories/preprod/inventory haproxy.yml -e "cluster=preprod"
+  
+  echo "proceeding"
+  echo "committing changes"
+  git add preprod-haproxy.cfg
+  git commit -m "Sync haproxy"
+  git push origin master
+  `;
+  
+    await fs.writeFile('haproxy.sh', scriptContent);
+  
+    // Private key
+    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);
+  
+    await $`cat private.key`; // Just to mimic the script's behavior
+  
+    // Copy script to remote
+    await $`scp -i private.key -o StrictHostKeyChecking=no haproxy.sh root@10.10.28.198:/tmp/haproxy.sh`;
+  
+    // Execute script on remote
+    await $`ssh -i private.key -o StrictHostKeyChecking=no root@10.10.28.198 "bash /tmp/haproxy.sh"`;
+  }