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

package/src/next/git-to-semver.js

@@ -0,0 +1,79 @@
+/**
+ * Converts git describe output to semantic versioning format
+ *
+ * Logic based on dash count:
+ * - 2 dashes: Released version with commits (v1.2.3-4-g1234567 -> 1.2.3+4.g1234567)
+ * - 3 dashes: Pre-release with commits (v1.2.3-rc.1-4-g1234567 -> 1.2.3-rc.1+4.g1234567)
+ * - 1 dash: Pre-release tag only (v1.2.3-rc.1 -> 1.2.3-rc.1)
+ * - 0 dashes: Clean tag (v1.2.3 -> 1.2.3)
+ *
+ * @param {string} gitDescribe - The output from git describe
+ * @return {string} Semver compatible version string
+ */
+export function gitDescribeToSemver(gitDescribe) {
+  if (!gitDescribe || typeof gitDescribe !== 'string') {
+    throw new Error('Invalid input: git describe string required');
+  }
+
+  // Remove leading 'v' if present
+  let version = gitDescribe.trim();
+  if (version.startsWith('v') || version.startsWith('V')) {
+    version = version.substring(1);
+  }
+
+  // Count dashes to determine format
+  const dashCount = (version.match(/-/g) || []).length;
+
+  switch (dashCount) {
+    case 0:
+      // Clean tag: 1.2.3
+      return version;
+
+    case 1:
+      // Pre-release tag only: 1.2.3-rc.1
+      return version;
+
+    case 2: {
+      // Released version with commits: 1.2.3-4-g1234567
+      // Split: [1.2.3, 4, g1234567]
+      const parts = version.split('-');
+      const baseVersion = parts[0];
+      const commits = parts[1];
+      const hash = parts[2];
+      return `${baseVersion}+${commits}.${hash}`;
+    }
+
+    case 3: {
+      // Pre-release with commits: 1.2.3-rc.1-4-g1234567
+      // Split: [1.2.3, rc.1, 4, g1234567]
+      const parts = version.split('-');
+      const baseVersion = parts[0];
+      const prerelease = parts[1];
+      const commits = parts[2];
+      const hash = parts[3];
+      return `${baseVersion}-${prerelease}+${commits}.${hash}`;
+    }
+
+    default: {
+      // More than 3 dashes - handle complex pre-release tags
+      // e.g., 1.2.3-rc-1-beta-4-g1234567
+      // Assume last two parts are commits-hash
+      const parts = version.split('-');
+      if (
+        parts.length >= 3 &&
+        /^\d+$/.test(parts[parts.length - 2]) &&
+        /^g[a-f0-9]+$/.test(parts[parts.length - 1])
+      ) {
+        // Has commits and hash at the end
+        const commits = parts[parts.length - 2];
+        const hash = parts[parts.length - 1];
+        const versionParts = parts.slice(0, -2);
+        const baseVersion = versionParts[0];
+        const prerelease = versionParts.slice(1).join('-');
+        return `${baseVersion}-${prerelease}+${commits}.${hash}`;
+      }
+      // No commits/hash pattern found, treat as complex pre-release
+      return version;
+    }
+  }
+}

package/src/next/haproxy.js

@@ -0,0 +1,76 @@
+import { $ } from 'zx';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function haproxySync() {
+  const cluster = process.env.HAPROXY_CLUSTER;
+  if (cluster !== 'preprod' && cluster !== 'stage' && cluster !== 'prod-www3') {
+    console.log('Error: Cluster must be preprod or stage');
+    process.exit(1);
+  }
+
+  const repoPath = '/root/repo/docupace-ansible';
+  const inventory = path.join(repoPath, `inventories/${cluster}/inventory`);
+
+  // Create haproxy.sh
+  const cluserHostMap = {
+    preprod: {
+      host: '10.10.28.198',
+      branch: 'master',
+    },
+    stage: {
+      host: '10.12.28.10',
+      branch: 'master',
+    },
+    'prod-www2': {
+      host: ' 10.13.28.43',
+      branch: 'master',
+    },
+    'prod-www3': {
+      host: '10.13.28.45',
+      branch: 'master',
+    },
+  };
+
+  const scriptContent = `
+  #!/bin/bash
+  
+  [[ ! -f ${inventory} ]] && ( echo "Alert: no inventory file: ${inventory}" ; exit 1 )
+  cd ${repoPath}
+  pwd
+  git reset --hard
+  git clean -fd
+  git fetch --all
+  git pull origin master
+  git checkout ${cluserHostMap[cluster].branch}
+  git submodule update --remote
+  git submodule foreach --recursive git checkout master
+  git submodule foreach --recursive git pull origin master
+  
+  ansible-playbook -i inventories/${cluster}/inventory haproxy.yml -e "cluster=${cluster}  -e build=true"
+  
+  echo "proceeding"
+  echo "committing changes"
+  git add ${cluster}-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) {
+    console.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);
+
+  // Copy script to remote
+  await $`scp -i private.key -o StrictHostKeyChecking=no haproxy.sh root@${cluserHostMap[cluster].host}:/tmp/haproxy.sh`;
+
+  // Execute script on remote
+  await $`ssh -i private.key -o StrictHostKeyChecking=no root@${cluserHostMap[cluster].host} "bash /tmp/haproxy.sh"`;
+}

package/src/next/jenkins.js

@@ -1,7 +1,7 @@
 import axios from 'axios';
 
-const CORE_JENKINS_URL = 'http://devops.corp.docupace.com';
-const CORE_JOB_NAME = 'auto-deploy-site';
+const CORE_JENKINS_URL = process.env.CORE_JENKINS_URL;
+const CORE_JOB_NAME = process.env.CORE_JENKINS_JOB_NAME;
 const CORE_USERNAME = process.env.CORE_JENKINS_USERNAME;
 const CORE_API_TOKEN = process.env.CORE_JENKINS_API_TOKEN;
 
@@ -26,6 +26,7 @@ export async function deployCore(env, site, liquibase, gitBranch) {
   });
 }
 
+// eslint-disable-next-line no-unused-vars
 export async function deployConnect(env, site, liquibase, branch) {
   const parameters = {
     BUILD_ENVIRONMENT: env,

package/src/next/jira.js

@@ -0,0 +1,84 @@
+import axios from 'axios';
+
+// Create preconfigured axios instance for Jira
+const jiraClient = axios.create({
+  baseURL: 'https://docupacellc.atlassian.net',
+  auth: {
+    username: process.env.JIRA_API_EMAIL,
+    password: process.env.JIRA_API_KEY,
+  },
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+/**
+ * Updates the component version custom field in Jira
+ * @param {string} issueKey - The Jira issue key
+ * @param {string} packageName - The package name
+ * @param {string} version - The version to set
+ */
+export async function updateComponentVersion(issueKey, packageName, version) {
+  const component = packageName.includes('/')
+    ? packageName.split('/')[1]
+    : packageName;
+  console.log(
+    `Updating ${issueKey} for package ${packageName} translated to component ${component} with version ${version}`,
+  );
+  try {
+    // First get current field value
+    const response = await jiraClient.get(
+      `/rest/api/2/issue/${issueKey}?fields=customfield_10458`,
+    );
+
+    let currentValue = response.data.fields.customfield_10458 || '';
+    let components = new Map();
+
+    try {
+      // Parse existing components
+      if (currentValue) {
+        currentValue.split(';').forEach((entry) => {
+          const [comp, ver] = entry.split(':');
+          components.set(comp, ver);
+        });
+      }
+      // Update or add new component version
+    } catch {
+      console.log('Patch version has incorrect data overriding');
+    }
+
+    components.set(component, version);
+
+    // Convert back to string format
+    const newValue = Array.from(components.entries())
+      .map(([comp, ver]) => `${comp}:${ver}`)
+      .join(';');
+
+    // Update the field
+    await jiraClient.put(`/rest/api/2/issue/${issueKey}`, {
+      fields: {
+        customfield_10458: newValue,
+      },
+    });
+
+    console.log(`Updated component versions for ${issueKey}: ${newValue}`);
+  } catch (error) {
+    console.error(`Error updating Jira component version: ${error.message}`);
+  }
+}
+
+/**
+ * Makes a request to the Jira API using preconfigured client
+ * @param {string} endpoint - The API endpoint (starting with /)
+ * @param {Object} options - Request options (method, body, etc)
+ * @returns {Promise<any>} The response data
+ */
+export async function makeJiraRequest(endpoint, options = {}) {
+  try {
+    const response = await jiraClient.get(endpoint, options);
+    return response.data;
+  } catch (error) {
+    console.error(`Error making Jira request: ${error.message}`);
+    throw error;
+  }
+}

package/src/next/logger.js

@@ -0,0 +1,17 @@
+import { $ as original$ } from 'zx';
+
+// Wrapped version of $
+export const $ = async (strings, ...values) => {
+  const command = strings.reduce(
+    (acc, str, i) => acc + str + (values[i] ?? ''),
+    '',
+  );
+  console.log(`Executing: ${command}`);
+  try {
+    const result = await original$(strings, ...values);
+    return result;
+  } catch (error) {
+    console.error(`Error executing: ${command}`, error);
+    throw error;
+  }
+};

package/src/next/pipline.js

@@ -99,7 +99,6 @@ export async function runPipeline(
       return;
     }
 
-
     let status = '';
     do {
       console.log('Checking pipeline status...');

package/src/next/publish.js

@@ -1,48 +1,71 @@
-import { $ } from 'zx';
+import { $ } from './logger.js';
 
-export async function publish(GIT_SHA) {
-  const BITBUCKET_REPO_SLUG = process.env.BITBUCKET_REPO_SLUG;
-  const BUILD_IMAGE_NAME = `${BITBUCKET_REPO_SLUG}:build-${process.env.BITBUCKET_BUILD_NUMBER}`;
-  const IMAGE_NAME = `${BITBUCKET_REPO_SLUG}:sha-${GIT_SHA}`;
-  const JF_REGISTRY_FULL_URL = `${process.env.JF_REGISTRY_URL}/${process.env.JF_REGISTRY_REPO_NAME}`;
+const {
+  JF_REGISTRY_URL,
+  JF_REGISTRY_REPO_NAME,
+  JF_REGISTRY_PASSWORD_DEV,
+  JF_REGISTRY_USER_DEV,
+  BITBUCKET_REPO_SLUG,
+  BITBUCKET_BUILD_NUMBER,
+  APP_NAME,
+} = process.env;
 
-  console.log(`Publishing Docker image: ${IMAGE_NAME}`);
+const JF_REGISTRY_FULL_URL = `${JF_REGISTRY_URL}/${JF_REGISTRY_REPO_NAME}`;
 
-  // Docker login
-  await $`echo ${process.env.JF_REGISTRY_PASSWORD_DEV} | docker login --username ${process.env.JF_REGISTRY_USER_DEV} --password-stdin ${process.env.JF_REGISTRY_URL}`;
+async function loginRegistry() {
+  await $`echo ${JF_REGISTRY_PASSWORD_DEV} | docker login --username ${JF_REGISTRY_USER_DEV} --password-stdin ${JF_REGISTRY_URL}`;
+}
+
+async function logoutRegistry() {
+  await $`docker logout ${JF_REGISTRY_URL}`;
+}
+
+export async function publish(gitSha) {
+  process.env.DOCKER_HOST = '';
+
+  console.log(JSON.stringify(process.env));
+
+  const IMAGE_PREFIX = APP_NAME ?? BITBUCKET_REPO_SLUG;
+  const BUILD_IMAGE_NAME = `${IMAGE_PREFIX}:build-${BITBUCKET_BUILD_NUMBER}`;
+  const IMAGE_NAME = `${IMAGE_PREFIX}:sha-${gitSha}`;
+
+  console.log(`Publishing Docker image ${IMAGE_NAME}...`);
 
-  // Check if the image already exists
+  await loginRegistry();
+
+  let manifestExists = false;
   try {
+    $.verbose = false; // Silence output temporarily
     await $`docker manifest inspect ${JF_REGISTRY_FULL_URL}/${IMAGE_NAME}`;
+    manifestExists = true;
+  } catch {
+    manifestExists = false;
+  } finally {
+    $.verbose = true; // Restore normal output
+  }
+
+  if (manifestExists) {
     console.log(
-      `Tag sha-${GIT_SHA} already exists in the remote repository. Skipping push.`,
+      `Tag sha-${gitSha} already exists in the remote repository. Skipping push.`,
     );
-  } catch {
+  } else {
     await $`docker tag ${IMAGE_NAME} ${JF_REGISTRY_FULL_URL}/${IMAGE_NAME}`;
     await $`docker push ${JF_REGISTRY_FULL_URL}/${IMAGE_NAME}`;
   }
 
-  // Tag and push build image
   await $`docker tag ${IMAGE_NAME} ${JF_REGISTRY_FULL_URL}/${BUILD_IMAGE_NAME}`;
   await $`docker push ${JF_REGISTRY_FULL_URL}/${BUILD_IMAGE_NAME}`;
 
-  // Fetch Git tags pointing to the current HEAD
-  const gitTagsOutput = (await $`git tag --points-at HEAD`).stdout.trim();
-  const gitTags = gitTagsOutput.split('\n').filter((tag) => tag);
-
-  // Tag and push each Git tag as a Docker tag
-  if (gitTags.length > 0) {
-    console.log(`Found Git tags pointing to HEAD: ${gitTags.join(', ')}`);
-    for (const gitTag of gitTags) {
-      const dockerTag = `${JF_REGISTRY_FULL_URL}/${BITBUCKET_REPO_SLUG}:${gitTag}`;
-      console.log(`Tagging and pushing Docker image for Git tag: ${gitTag}`);
-      await $`docker tag ${IMAGE_NAME} ${dockerTag}`;
-      await $`docker push ${dockerTag}`;
-    }
-  } else {
-    console.log('No Git tags found pointing to the current HEAD.');
+  const gitTags = (await $`git tag --points-at HEAD`).stdout
+    .trim()
+    .split('\n')
+    .filter(Boolean);
+  for (const gitTag of gitTags) {
+    const version = gitTag.includes('@') ? 'v' + gitTag.split('@')[1] : gitTag;
+    const tagName = `${IMAGE_PREFIX}:${version}`;
+    await $`docker tag ${IMAGE_NAME} ${JF_REGISTRY_FULL_URL}/${tagName}`;
+    await $`docker push ${JF_REGISTRY_FULL_URL}/${tagName}`;
   }
 
-  // Docker logout
-  await $`docker logout ${process.env.JF_REGISTRY_URL}`;
+  await logoutRegistry();
 }

package/src/next/test.js

@@ -0,0 +1,5 @@
+import { getBranchNameFromVersion } from './deploy.js';
+
+getBranchNameFromVersion('25.2.0-alpha.18-3-g4e0e088aa0');
+getBranchNameFromVersion('25.1.13-0-g7798cf7138');
+getBranchNameFromVersion('25.1.13-3-g7798cf7138');

package/src/next/util.js

@@ -0,0 +1,95 @@
+import { existsSync } from 'fs';
+import path, { join } from 'path';
+import { $ } from 'zx';
+
+export function isMonoRepo() {
+  // Check for the presence of turbo.json which indicates a Turborepo monorepo
+  return existsSync(join(process.cwd(), 'turbo.json'));
+}
+
+/**
+ * Gets the packages that have changed between two git references (branches or tags)
+ * @param {string} fromRef - The starting git reference (branch or tag)
+ * @param {string} toRef - The ending git reference (branch or tag)
+ * @returns {Promise<Array<{name: string, path: string}>>} - Array of changed packages with name and path
+ */
+export async function getChangedPackagesInternal(fromRef, toRef) {
+  try {
+    console.log(process.cwd());
+    // Run the turbo command to get changed packages between branches
+    const filterArg = `[${fromRef}...${toRef}]`;
+    const turboDryOutput =
+      await $`turbo run build --filter=${filterArg} --dry=json`;
+
+    const dryRunJson = turboDryOutput.stdout.trim();
+
+    const dryRun = JSON.parse(dryRunJson);
+
+    const packages = dryRun.tasks.map((task) => ({
+      name: task.package,
+      directory: task.directory,
+      path: path.resolve(process.cwd(), task.directory),
+    }));
+
+    return packages;
+  } catch (error) {
+    console.error('Error getting changed packages:', error);
+    return [];
+  }
+}
+
+export async function getAllPackages() {
+  try {
+    const turboDryOutput = await $`turbo run build --dry=json`;
+    const dryRunJson = turboDryOutput.stdout.trim();
+    const dryRun = JSON.parse(dryRunJson);
+
+    const packages = dryRun.tasks.map((task) => ({
+      name: task.package,
+      directory: task.directory,
+      path: path.resolve(process.cwd(), task.directory),
+    }));
+
+    return packages;
+  } catch (error) {
+    console.error('Error getting changed packages:', error);
+    return [];
+  }
+}
+
+export async function getAllAppPackages() {
+  const changedPackages = await getAllPackages();
+  const appPackages = changedPackages.filter((appPackage) =>
+    appPackage.directory.startsWith('apps'),
+  );
+  return appPackages;
+}
+
+export async function getChangedPackages() {
+  const branch = process.env.BITBUCKET_BRANCH;
+  const destBranch = process.env.BITBUCKET_PR_DESTINATION_BRANCH;
+
+  await $`git fetch origin ${destBranch}:${destBranch}`;
+  console.log(`Getting changed packages for [${destBranch}...${branch}]`);
+  const changedPackages = await getChangedPackagesInternal(destBranch, branch);
+  console.log('Changed Packages:\n', JSON.stringify(changedPackages, null, 2));
+  return changedPackages;
+}
+
+export async function getChangedAppPackages() {
+  const changedPackages = await getChangedPackages();
+  const appPackages = changedPackages.filter((appPackage) =>
+    appPackage.directory.startsWith('apps'),
+  );
+  return appPackages;
+}
+
+export async function setGitInfo() {
+  if (!process.env.IS_DEV) {
+    await $`git config --global user.email "gitops@docupace.com"`;
+    await $`git config --global user.name "Gitops"`;
+    const repoUrl = `git@bitbucket.org:dp-cloud/${process.env.BITBUCKET_REPO_SLUG}.git`;
+    console.log(`Setting new origin: ${repoUrl}`);
+    await $`git remote set-url origin ${repoUrl}`;
+  }
+}

package/src/next/vault.js

@@ -0,0 +1,45 @@
+import axios from 'axios';
+
+export async function vaultAddSiteData(SITE, SITE_CONFIG_REMOTE_PATH) {
+  const AUTH0_CLIENT_ID = process.env.AUTH0_CLIENT_ID;
+  const AUTH0_CLIENT_SECRET = process.env.AUTH0_CLIENT_SECRET;
+  const VAULT_ADDR = process.env.VAULT_ADDR; // Vault host URL from environment variables
+  const VAULT_TOKEN = process.env.VAULT_TOKEN; // Vault token from environment variables
+
+  if (!VAULT_ADDR || !VAULT_TOKEN) {
+    throw new Error('Missing VAULT_ADDR or VAULT_TOKEN environment variable.');
+  }
+
+  const vaultApiUrl = `${VAULT_ADDR}/v1/secret/data/${SITE}/common/config`;
+
+  try {
+    if (process.env.VAULT_SKIP_VERIFY === 'true') {
+      process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+    }
+
+    const response = await axios.post(
+      vaultApiUrl,
+      {
+        data: {
+          AUTH0_CLIENT_ID: AUTH0_CLIENT_ID,
+          AUTH0_CLIENT_SECRET: AUTH0_CLIENT_SECRET,
+          SITE_CONFIG_REMOTE_PATH: SITE_CONFIG_REMOTE_PATH,
+        },
+      },
+      {
+        headers: {
+          'X-Vault-Token': VAULT_TOKEN,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    console.log('Data added to Vault successfully:', response.data);
+  } catch (error) {
+    console.error(
+      'Error adding data to Vault:',
+      error.response?.data || error.message,
+    );
+    throw error;
+  }
+}

package/terraform/apply.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -e
+
+PROJECT=$1
+export ROLE_NAME="${2:-atlassian-bitbucket-pipelines-runner-eks-role}"
+CLUSTER_NAME="${3:-}"
+
+if [[ -z "$PROJECT" ]]; then
+  echo "Error: Project name is required."
+  echo "Usage: $0 <project-name>"
+  exit 1
+fi
+
+if [ -n "$CLUSTER_NAME" ]; then
+  export EKS_CLUSTER_NAME="$CLUSTER_NAME"
+elif [ "$CURRENT_ENVIRONMENT" == "prd" ]; then
+  export EKS_CLUSTER_NAME="connect-next-prd-eks-cluster"
+  CURRENT_ENVIRONMENT="prod"
+elif [ "$CURRENT_ENVIRONMENT" == "stg" ]; then
+  export EKS_CLUSTER_NAME="connect-next-stg-eks-cluster"
+  CURRENT_ENVIRONMENT="stage"
+else
+  export EKS_CLUSTER_NAME="connect-next-${CURRENT_ENVIRONMENT}-eks-cluster"
+fi
+
+echo "Using EKS cluster: $EKS_CLUSTER_NAME"
+echo "Current environment: $CURRENT_ENVIRONMENT"
+
+export SESSION_NAME="EKSAdminSession"
+export ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity | jq -r '.Account'):role/$ROLE_NAME"
+export ASSUME_ROLE_OUTPUT=$(aws sts assume-role --role-arn $ROLE_ARN --role-session-name $SESSION_NAME)
+export AWS_ACCESS_KEY_ID=$(echo $ASSUME_ROLE_OUTPUT | jq -r '.Credentials.AccessKeyId')
+export AWS_SECRET_ACCESS_KEY=$(echo $ASSUME_ROLE_OUTPUT | jq -r '.Credentials.SecretAccessKey')
+export AWS_SESSION_TOKEN=$(echo $ASSUME_ROLE_OUTPUT | jq -r '.Credentials.SessionToken')
+export TF_IN_AUTOMATION=1
+
+aws sts get-caller-identity
+
+cd "$BITBUCKET_CLONE_DIR/${PROJECT}"
+
+terraform apply -input=false .tfplan