@docupace/pipeline 1.0.1 → 1.0.2-3.tes2

package/src/jenkins/setParams.groovy

@@ -0,0 +1,59 @@
+import groovy.json.JsonSlurper
+
+import hudson.model.*;
+
+def build = Thread.currentThread().executable
+def params = build.getEnvironment(listener)
+
+def site = params.get('site')
+def server = "jboss7"
+def environment = params.get('environment')
+
+def buildFile=new File("D:\\Docupace\\CustomFolders\\" + environment + "\\" + site + "\\" + server + "\\buildApp.properties")
+
+List<String> jboss7controllerResult = []
+
+def controllersReport = new File("D:\\Docupace\\controllers_report.json")
+def inputJSON = new JsonSlurper().parseText(controllersReport.text)
+def props = new Properties()
+buildFile.withInputStream { stream -> props.load(stream) }
+def webRootContext = props["web.root.context"]
+if (webRootContext == null || webRootContext =="core") webRootContext = props["docupace.config.client.id"].toLowerCase()
+
+webRootContext  = webRootContext.replaceFirst('_sso','')
+def map = inputJSON.'content'
+
+def Boolean enabled
+
+map.each {k,v ->
+    v.each{vk, vv -> if (vk == webRootContext ) {
+        enabled = false
+        if(vv.deploymentsProperty.size()>0) enabled = vv.deploymentsProperty[0].isEnabled
+        if (enabled) jboss7controllerResult.push(k)
+        else jboss7controllerResult << k
+    }
+    }
+}
+
+if (jboss7controllerResult.size()>0) {
+    if (environment == 'preprod') {
+        jboss7controllerResult.remove("dev-corjbdc10.corp.docupace.com")
+        jboss7controllerResult.remove("usdoc-s-jbdc1.corp.docupace.com")
+    }
+    if (environment == 'dev') {
+        jboss7controllerResult.remove("qa-corjbdc10.corp.docupace.com")
+        jboss7controllerResult.remove("qa-corjbdc20.corp.docupace.com")
+        jboss7controllerResult.remove("usdoc-s-jbdc2.corp.docupace.com")
+    }
+}
+
+println jboss7controllerResult[0]
+
+env.jboss7controller = jboss7controllerResult[0]
+
+def serverGroup = inputJSON.'content'."${jboss7controller}"."${webRootContext}".'serverGroup'
+
+println serverGroup
+
+params.put("serverGroup", serverGroup)
+

package/src/next/alias.js

@@ -0,0 +1,53 @@
+import { BasicAuth, DomainApi } from '@docupace/core-client';
+
+const userFilter = (userId) => {
+  return {
+    orSections: [
+      {
+        andSections: [
+          {
+            attrId: 9501,
+            '@type': 'string',
+            not: false,
+            orSections: [
+              { searchType: 'EXACT_MATCH', matchToValues: [userId] },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+};
+
+/*
+Example:
+  await createAlias(
+    'https://www.dev.docupaceinc.com/financialdev',
+    'docupace',
+    'pw',
+    'Connect',
+    'qhnospjRjwUAeKFDhucHEabPsfihrGQQ@clients',
+  );
+ */
+export async function createAlias(coreUrl, username, password, realm, alias) {
+  const coreInfo = {
+    url: coreUrl,
+  };
+
+  let auth = new BasicAuth(username, password);
+
+  const domainApi = new DomainApi(coreInfo, auth);
+
+  const userResults = await domainApi.listRecords(50, {
+    filter: JSON.stringify(userFilter(username)),
+  });
+
+  const record = {
+    domainId: 302,
+    '5001': userResults.records[0].id,
+    '9102': realm,
+    '9504': alias,
+  };
+
+  await domainApi.create(record);
+}

package/src/next/apache.js

@@ -0,0 +1,40 @@
+import { $ } from 'zx';
+
+export async function addApacheSite() {
+    if (
+      !process.env.ENVIRONMENT ||
+      (process.env.ENVIRONMENT !== 'dev' && process.env.ENVIRONMENT !== 'qa')
+    ) {
+      log("Error: ENVIRONMENT must be either 'dev' or 'qa'.");
+      process.exit(1);
+    }
+    if (!process.env.SITE) {
+      log('Error: SITE cannot be empty.');
+      process.exit(1);
+    }
+  
+    // 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}`;
+  
+    let server = `${process.env.ENVIRONMENT}-apalb01a.corp.docupace.com`;
+    // The script is run twice in the Bash version
+    await sshCmd(server, `/root/repo/iis-preprod/scripts/addsite/add_core_site.sh ${process.env.ENVIRONMENT} ${process.env.SITE}`);
+
+    server = `${process.env.ENVIRONMENT}-apalb01b.corp.docupace.com`;
+
+    await sshCmd(server,`/root/repo/iis-preprod/scripts/addsite/add_core_site.sh ${process.env.ENVIRONMENT} ${process.env.SITE}`);
+  }
+  
+  

package/src/next/cli.js

@@ -4,56 +4,173 @@ import { Command } from 'commander';
 import { pull } from './pull.js';
 import { sonar } from './sonar.js';
 import { publish } from './publish.js';
-import { deploy } from './deploy.js';
+import { deployFromSite } from './deploy.js';
 import { deployTemplate } from './deploy.js';
 import { copy } 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';
+
+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
-    .command('pull <imageName>')
-    .description('Pull a Docker image from the registry')
-    .action(async (imageName) => {
-        await pull(imageName);
-    });
+  .command('pull <imageName>')
+  .description('Pull a Docker image from the registry')
+  .action(async (imageName) => {
+    await pull(imageName);
+  });
 
 program
-    .command('sonar')
-    .description('Run Sonar analysis')
-    .action(async () => {
-        await sonar(GIT_SHA);
-    });
+  .command('sonar')
+  .description('Run Sonar analysis')
+  .action(async () => {
+    await sonar(GIT_SHA);
+  });
 
 program
-    .command('publish')
-    .description('Publish a Docker image')
-    .action(async () => {
-        await publish(GIT_SHA);
-    });
+  .command('addApacheSite')
+  .description('Add site to apache')
+  .action(async () => {
+    await addApacheSite();
+  });
 
 program
-    .command('deploy <application> <site>')
-    .description('Deploy an application for a specific site')
-    .action(async (application, site) => {
-        await deploy(application, site);
-    });
+  .command('connectClone')
+  .description('Clone connect site')
+  .action(async () => {
+    await connectClone();
+  });
 
 program
-    .command('deployTemplate <site>')
-    .description('Deploy an application for a specific site')
-    .action(async (site) => {
-        await deployTemplate(site);
-    });
+  .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')
+  .action(async () => {
+    await publish(GIT_SHA);
+  });
+
+program
+  .command('deploy-from-site')
+  .description('Deploy an application for a specific site')
+  .requiredOption('-f, --from-env <fromEnv>', 'Source environment')
+  .requiredOption('-t, --to-env <toEnv>', 'Target environment')
+  .requiredOption('-F, --from-site <fromSite>', 'Source site')
+  .requiredOption('-T, --to-site <toSite>', 'Target site')
+  .option('-c, --deploy-core <deployCore>', 'Deploy Core', 'false')
+  .action(async (options) => {
+    const { fromEnv, fromSite, toEnv, toSite, deployCore } = options;
+    await deployFromSite(fromEnv, fromSite, toEnv, toSite, deployCore);
+  });
+
+program
+  .command('deployTemplate <site>')
+  .description('Deploy an application for a specific site')
+  .action(async (site) => {
+    await deployTemplate(site);
+  });
+
+program
+  .command('deploy-core <env> <site>')
+  .description('Deploy Core')
+  .option('-l, --liquibase <liquibase>', 'Application name', 'true')
+  .option('-b, --branch <branch>', 'Branch', 'master')
+  .action(async (env, site, options) => {
+    await deployCore(env, site, options.liquibase, options.branch);
+  });
+
+program
+  .command('deploy-connect <env> <site>')
+  .description('Deploy Core')
+  .option('-l, --liquibase <liquibase>', 'Application name', 'true')
+  .option('-b, --branch <branch>', 'Branch', 'master')
+  .action(async (env, site, options) => {
+    await deployConnect(env, site, options.liquibase, options.branch);
+  });
 
 program
-    .command('copy')
-    .description('Copy a Docker image between registries')
-    .action(async () => {
-        await copy();
+  .command('deploy-core-pipeline <env> <site>')
+  .description('Deploy Core')
+  .option('-l, --liquibase <liquibase>', 'Application name', 'true')
+  .option('-b, --branch <branch>', 'Branch', 'master')
+  .action(async (env, site, options) => {
+    await runPipeline('site-deploy', 'deploy-core', 'main', {
+      ENV: env,
+      SITE: site,
+      LIQUIBASE: options.liquibase,
+      BRANCH: options.branch,
     });
+  });
+
+program
+  .command('copy')
+  .description('Copy a Docker image between registries')
+  .requiredOption('-a, --application <application>', 'Application name')
+  .requiredOption('-f, --from-env <fromEnv>', 'Source environment')
+  .requiredOption('-t, --to-env <toEnv>', 'Target environment')
+  .requiredOption('-g, --tag <tag>', 'Image tag')
+  .action(async (options) => {
+    const { application, fromEnv, toEnv, tag } = options;
+    await copy(application, fromEnv, toEnv, tag);
+  });
+
+program
+  .command('run-pipeline')
+  .description('Trigger a pipeline by name')
+  .requiredOption('-r, --repository <repository>', 'Repository name')
+  .requiredOption('-p, --pipeline-name <pipelineName>', 'Pipeline name')
+  .requiredOption('-b, --branch <branch>', 'Branch name')
+  .option(
+    '-v, --variables <key=value>',
+    'Pipeline variable as key=value pair',
+    (value, previous) => {
+      const [key, val] = value.split('=');
+      if (!key || val === undefined) {
+        throw new Error(`Invalid variable format: ${value}. Use key=value.`);
+      }
+      return { ...previous, [key]: val };
+    },
+    {},
+  )
+  .option('-w, --wait', 'Wait for the pipeline to complete', false) // Defaults to false
+  .action(async (cmdObj) => {
+    try {
+      const { repository, pipelineName, branch, variables, wait } = cmdObj;
+
+      // Call the triggerPipelineByName function
+      await runPipeline(repository, pipelineName, branch, variables, wait);
+    } catch (error) {
+      console.error('Error triggering pipeline:', error.message);
+      process.exit(1);
+    }
+  });
 
 program.parse(process.argv);

package/src/next/config.js

@@ -0,0 +1,84 @@
+export const environments = ['dev', 'qa', 'uat', 'stage', 'prod'];
+
+export const environmentConfig = {
+  dev: {
+    newUrl: (site) => `https://${site}.dev.dpai.tech`,
+    oldUrl: (site) => `https://www.dev.docupaceinc.com/${site}`,
+    docupaceHost: () => 'www.dev.docupaceinc.com',
+  },
+  qa: {
+    newUrl: (site) => `https://${site}.qa.dpai.tech`,
+    oldUrl: (site) => `https://www.preprod.docupaceinc.com/${site}`,
+    docupaceHost: () => 'www.preprod.docupaceinc.com',
+  },
+  uat: {
+    newUrl: (site) => `https://${site}.qa.dpai.tech`,
+    oldUrl: (site) => `https://www2.paperout.com/${site}_uat`,
+    docupaceHost: () => 'www2.paperout.com',
+  },
+  stage: {
+    newUrl: (site) => `https://${site}.stage.dpai.tech`,
+    oldUrl: (site) => `https://www2.paperout.com/${site}_staging`,
+    docupaceHost: () => 'www2.paperout.com',
+  },
+  prod: {
+    newUrl: (site) => `https://${site}.dpai.tech`,
+    oldUrl: (site) => `https://www2.paperout.com/${site}`,
+    docupaceHost: () => 'www2.paperout.com',
+  },
+};
+
+export const appInfo = {
+  'graphql-server': {
+    repositoryName: 'docupace-graphql-server',
+    deployAttributes: [
+      'image.tag',
+      'graphqlServer.siteConfigRemoteBranch',
+      'graphqlServer.standardConfigRemoteBranch',
+    ],
+  },
+  ui: {
+    repositoryName: 'docupace-ui-main',
+    deployAttributes: ['image.tag'],
+  },
+};
+
+export const getEnvInfo = () => {
+  const envInfo = Object.fromEntries(
+    environments.map((env) => [
+      env,
+      {
+        jfrog: {
+          username: process.env[`JF_REGISTRY_${env.toUpperCase()}_USERNAME`],
+          password: process.env[`JF_REGISTRY_${env.toUpperCase()}_PASSWORD`],
+        },
+      },
+    ]),
+  );
+
+  return envInfo;
+};
+
+export const getBitbucketInfo = () => {
+  return {
+    username: process.env.BITBUCKET_USERNAME,
+    password: process.env.BITBUCKET_APP_PASSWORD,
+    workspace: 'dp-cloud',
+  };
+};
+
+export const getRepUrl = (repoName) => {
+  const { username, password, workspace } = getBitbucketInfo();
+  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`
+  }
+};

package/src/next/connect.js

@@ -0,0 +1,199 @@
+import 'zx/globals'; // npm i zx
+import fs from 'fs-extra';
+import path from 'path';
+import axios from 'axios';
+import { $ } from 'zx';
+
+
+
+import {
+  cloneEnvRepository,
+  cloneRepository
+} from './deploy.js';
+
+
+import { getVaultSecrets } from '../auth0/vault.js';
+
+import {
+  getVaultSecretsConfigs,
+  environmentConfig
+} from './config.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',
+  'stg': 'stg',
+  'uat': 'uat',
+  'prd': 'prod-las'
+};
+
+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.BUILD_ENVIRONMENT];
+     const connectToEnv = connectUIEnvMap[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-${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(`${connectToEnv}-site-settings`, `${process.env.CONNECT_DIR}/${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}`);
+
+    const connectHome = path.join(projectRoot,process.env.CONNECT_DIR);
+    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}`;
+            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
+          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 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`;
+    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`;
+    } else {
+      log('No changes have been made. The site likely already has the correct configuration.');
+    }
+  }
+