underpost 2.89.45 → 2.90.0

package/src/cli/deploy.js

@@ -37,36 +37,6 @@ const logger = loggerFactory(import.meta);
 class UnderpostDeploy {
   static NETWORK = {};
   static API = {
-    /**
-     * Synchronizes deployment configurations for a list of deployments.
-     * @param {string} deployList - List of deployment IDs to synchronize.
-     * @param {object} options - Options for the synchronization process.
-     * @param {string} options.versions - Comma-separated list of versions to deploy.
-     * @param {string} options.replicas - Number of replicas for each deployment.
-     * @param {string} options.node - Node name for resource allocation.
-     * @returns {object} - Deployment data for the specified deployments.
-     * @memberof UnderpostDeploy
-     */
-    sync(deployList, { versions, replicas, node }) {
-      fs.writeFileSync(`./engine-private/deploy/dd.router`, deployList, 'utf8');
-      const totalPods = deployList.split(',').length * versions.split(',').length * parseInt(replicas);
-      const limitFactor = 0.8;
-      const reserveFactor = 0.05;
-      const resources = UnderpostCluster.API.getResourcesCapacity(node);
-      const memory = parseInt(resources.memory.value / totalPods);
-      const cpu = parseInt(resources.cpu.value / totalPods);
-      UnderpostRootEnv.API.set(
-        'resources.requests.memory',
-        `${parseInt(memory * reserveFactor)}${resources.memory.unit}`,
-      );
-      UnderpostRootEnv.API.set('resources.requests.cpu', `${parseInt(cpu * reserveFactor)}${resources.cpu.unit}`);
-      UnderpostRootEnv.API.set('resources.limits.memory', `${parseInt(memory * limitFactor)}${resources.memory.unit}`);
-      UnderpostRootEnv.API.set('resources.limits.cpu', `${parseInt(cpu * limitFactor)}${resources.cpu.unit}`);
-      UnderpostRootEnv.API.set('total-pods', totalPods);
-      return getDataDeploy({
-        buildSingleReplica: true,
-      });
-    },
     /**
      * Creates a router configuration for a list of deployments.
      * @param {string} deployList - List of deployment IDs to include in the router.
@@ -130,18 +100,28 @@ class UnderpostDeploy {
      * @param {number} replicas - Number of replicas for the deployment.
      * @param {string} image - Docker image for the deployment.
      * @param {string} namespace - Kubernetes namespace for the deployment.
+     * @param {Array<object>} volumes - Volume configurations for the deployment.
+     * @param {Array<string>} cmd - Command to run in the deployment container.
      * @returns {string} - YAML deployment configuration for the specified deployment.
      * @memberof UnderpostDeploy
      */
-    deploymentYamlPartsFactory({ deployId, env, suffix, resources, replicas, image, namespace }) {
+    deploymentYamlPartsFactory({ deployId, env, suffix, resources, replicas, image, namespace, volumes, cmd }) {
+      if (!cmd)
+        cmd = [
+          `npm install -g npm@11.2.0`,
+          `npm install -g underpost`,
+          `underpost secret underpost --create-from-file /etc/config/.env.${env}`,
+          `underpost start --build --run ${deployId} ${env}`,
+        ];
       const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
-      let volumes = [
-        {
-          volumeMountPath: '/etc/config',
-          volumeName: 'config-volume',
-          configMap: 'underpost-config',
-        },
-      ];
+      if (!volumes)
+        volumes = [
+          {
+            volumeMountPath: '/etc/config',
+            volumeName: 'config-volume',
+            configMap: 'underpost-config',
+          },
+        ];
       const confVolume = fs.existsSync(`./engine-private/conf/${deployId}/conf.volume.json`)
         ? JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.volume.json`, 'utf8'))
         : [];
@@ -166,21 +146,23 @@ spec:
       containers:
         - name: ${deployId}-${env}-${suffix}
           image: ${image ?? `localhost/rockylinux9-underpost:v${packageJson.version}`}
-#          resources:
-#            requests:
-#              memory: "${resources.requests.memory}"
-#              cpu: "${resources.requests.cpu}"
-#            limits:
-#              memory: "${resources.limits.memory}"
-#              cpu: "${resources.limits.cpu}"
+${
+  resources
+    ? `          resources:
+            requests:
+              memory: "${resources.requests.memory}"
+              cpu: "${resources.requests.cpu}"
+            limits:
+              memory: "${resources.limits.memory}"
+              cpu: "${resources.limits.cpu}"`
+    : ''
+}
           command:
             - /bin/sh
             - -c
             - >
-              npm install -g npm@11.2.0 &&
-              npm install -g underpost &&
-              underpost secret underpost --create-from-file /etc/config/.env.${env} &&
-              underpost start --build --run ${deployId} ${env}
+              ${cmd.join(` && `)}
+
 ${UnderpostDeploy.API.volumeFactory(volumes.map((v) => ((v.version = `${deployId}-${env}-${suffix}`), v)))
   .render.split(`\n`)
   .map((l) => '    ' + l)
@@ -209,7 +191,6 @@ spec:
      * @memberof UnderpostDeploy
      */
     async buildManifest(deployList, env, options) {
-      const resources = UnderpostDeploy.API.resourcesFactory();
       const replicas = options.replicas;
       const image = options.image;
       if (!options.namespace) options.namespace = 'default';
@@ -237,7 +218,6 @@ ${UnderpostDeploy.API.deploymentYamlPartsFactory({
   deployId,
   env,
   suffix: deploymentVersion,
-  resources,
   replicas,
   image,
   namespace: options.namespace,
@@ -253,27 +233,12 @@ ${UnderpostDeploy.API.deploymentYamlPartsFactory({
           : [];
 
         for (const host of Object.keys(confServer)) {
-          if (env === 'production') secretYaml += UnderpostDeploy.API.buildCertManagerCertificate({ host });
+          if (env === 'production')
+            secretYaml += UnderpostDeploy.API.buildCertManagerCertificate({ host, namespace: options.namespace });
 
           const pathPortAssignment = pathPortAssignmentData[host];
           // logger.info('', { host, pathPortAssignment });
-          let _proxyYaml = `
----
-apiVersion: projectcontour.io/v1
-kind: HTTPProxy
-metadata:
-  name: ${host}
-  namespace: ${options.namespace}
-spec:
-  virtualhost:
-    fqdn: ${host}${
-      env === 'development'
-        ? ''
-        : `
-    tls:
-      secretName: ${host}`
-    }
-  routes:`;
+          let _proxyYaml = UnderpostDeploy.API.baseProxyYamlFactory({ host, env, options });
           const deploymentVersions =
             options.traffic && typeof options.traffic === 'string' ? options.traffic.split(',') : ['blue'];
           let proxyRoutes = '';
@@ -347,18 +312,54 @@ spec:
     /**
      * Retrieves the current traffic status for a deployment.
      * @param {string} deployId - Deployment ID for which the traffic status is being retrieved.
+     * @param {object} options - Options for the traffic retrieval.
+     * @param {string} options.hostTest - Hostname to test for traffic status.
+     * @param {string} options.namespace - Kubernetes namespace for the deployment.
      * @returns {string|null} - Current traffic status ('blue' or 'green') or null if not found.
      * @memberof UnderpostDeploy
      */
-    getCurrentTraffic(deployId) {
+    getCurrentTraffic(deployId, options = { hostTest: '', namespace: '' }) {
+      if (!options.namespace) options.namespace = 'default';
       // kubectl get deploy,sts,svc,configmap,secret -n default -o yaml --export > default.yaml
-      const hostTest = Object.keys(
-        JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
-      )[0];
-      const info = shellExec(`sudo kubectl get HTTPProxy/${hostTest} -o yaml`, { silent: true, stdout: true });
+      const hostTest = options?.hostTest
+        ? options.hostTest
+        : Object.keys(JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')))[0];
+      const info = shellExec(`sudo kubectl get HTTPProxy/${hostTest} -n ${options.namespace} -o yaml`, {
+        silent: true,
+        stdout: true,
+      });
       return info.match('blue') ? 'blue' : info.match('green') ? 'green' : null;
     },
 
+    /**
+     * Creates a base YAML configuration for an HTTPProxy resource.
+     * @param {string} host - Hostname for which the HTTPProxy is being created.
+     * @param {string} env - Environment for which the HTTPProxy is being created.
+     * @param {object} options - Options for the HTTPProxy creation.
+     * @param {string} options.namespace - Kubernetes namespace for the HTTPProxy.
+     * @returns {string} - Base YAML configuration for the HTTPProxy resource.
+     * @memberof UnderpostDeploy
+     */
+    baseProxyYamlFactory({ host, env, options }) {
+      return `
+---
+apiVersion: projectcontour.io/v1
+kind: HTTPProxy
+metadata:
+  name: ${host}
+  namespace: ${options.namespace}
+spec:
+  virtualhost:
+    fqdn: ${host}${
+      env === 'development'
+        ? ''
+        : `
+    tls:
+      secretName: ${host}`
+    }
+  routes:`;
+    },
+
     /**
      * Callback function for handling deployment options.
      * @param {string} deployList - List of deployment IDs to process.
@@ -431,21 +432,39 @@ EOF`);
       if (options.status === true) {
         for (const _deployId of deployList.split(',')) {
           const deployId = _deployId.trim();
+          const instances = [];
+          if (fs.existsSync(`./engine-private/conf/${deployId}/conf.instances.json`)) {
+            const confInstances = JSON.parse(
+              fs.readFileSync(`./engine-private/conf/${deployId}/conf.instances.json`, 'utf8'),
+            );
+            for (const instance of confInstances) {
+              const _deployId = `${deployId}-${instance.id}`;
+              instances.push({
+                id: instance.id,
+                host: instance.host,
+                path: instance.path,
+                fromPort: instance.fromPort,
+                toPort: instance.toPort,
+                traffic: UnderpostDeploy.API.getCurrentTraffic(_deployId, { namespace, hostTest: instance.host }),
+              });
+            }
+          }
           logger.info('', {
             deployId,
             env,
-            traffic: UnderpostDeploy.API.getCurrentTraffic(deployId),
+            traffic: UnderpostDeploy.API.getCurrentTraffic(deployId, { namespace }),
             router: await UnderpostDeploy.API.routerFactory(deployId, env),
             pods: await UnderpostDeploy.API.get(deployId),
+            instances,
           });
         }
         const interfaceName = Dns.getDefaultNetworkInterface();
         logger.info('Machine', {
-          node: os.hostname(),
+          hostname: os.hostname(),
           arch: UnderpostBaremetal.API.getHostArch(),
           ipv4Public: await Dns.getPublicIp(),
           ipv4Local: getLocalIPv4Address(),
-          resources: UnderpostCluster.API.getResourcesCapacity(),
+          resources: UnderpostCluster.API.getResourcesCapacity(options.node),
           defaultInterfaceName: interfaceName,
           defaultInterfaceInfo: os.networkInterfaces()[interfaceName],
         });
@@ -453,7 +472,10 @@ EOF`);
       }
       if (!(options.versions && typeof options.versions === 'string')) options.versions = 'blue,green';
       if (!options.replicas) options.replicas = 1;
-      if (options.sync) UnderpostDeploy.API.sync(deployList, options);
+      if (options.sync)
+        getDataDeploy({
+          buildSingleReplica: true,
+        });
       if (options.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env, options);
       if (options.infoRouter === true || options.buildManifest === true) {
         logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
@@ -496,24 +518,15 @@ EOF`);
             shellExec(
               `sudo kubectl delete deployment ${deployId}-${env}-${version} -n ${namespace} --ignore-not-found`,
             );
-            if (!options.disableUpdateVolume) {
-              for (const volume of confVolume) {
-                const pvcId = `${volume.claimName}-${deployId}-${env}-${version}`;
-                const pvId = `${volume.claimName.replace('pvc-', 'pv-')}-${deployId}-${env}-${version}`;
-                const rootVolumeHostPath = `/home/dd/engine/volume/${pvId}`;
-                if (!fs.existsSync(rootVolumeHostPath)) fs.mkdirSync(rootVolumeHostPath, { recursive: true });
-                fs.copySync(volume.volumeMountPath, rootVolumeHostPath);
-                shellExec(`kubectl delete pvc ${pvcId} -n ${namespace} --ignore-not-found`);
-                shellExec(`kubectl delete pv ${pvId} --ignore-not-found`);
-                shellExec(`kubectl apply -f - -n ${namespace} <<EOF
-${UnderpostDeploy.API.persistentVolumeFactory({
-  hostPath: rootVolumeHostPath,
-  pvcId,
-})}
-EOF
-`);
-              }
-            }
+            if (!options.disableUpdateVolume)
+              for (const volume of confVolume)
+                UnderpostDeploy.API.deployVolume(volume, {
+                  deployId,
+                  env,
+                  version,
+                  namespace,
+                  nodeName: options.node ? options.node : env === 'development' ? 'kind-worker' : os.hostname(),
+                });
           }
 
         for (const host of Object.keys(confServer)) {
@@ -592,24 +605,7 @@ EOF
 
       return result;
     },
-    /**
-     * Retrieves the resources factory for a deployment.
-     * @returns {object} - Object containing the resources factory for the deployment.
-     * @memberof UnderpostDeploy
-     */
-    resourcesFactory() {
-      return {
-        requests: {
-          memory: UnderpostRootEnv.API.get('resources.requests.memory'),
-          cpu: UnderpostRootEnv.API.get('resources.requests.cpu'),
-        },
-        limits: {
-          memory: UnderpostRootEnv.API.get('resources.limits.memory'),
-          cpu: UnderpostRootEnv.API.get('resources.limits.cpu'),
-        },
-        totalPods: UnderpostRootEnv.API.get('total-pods'),
-      };
-    },
+
     /**
      * Checks if a container file exists in a pod.
      * @param {object} options - Options for the check.
@@ -706,6 +702,60 @@ EOF
       shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml -n ${namespace}`);
     },
 
+    /**
+     * Deploys a volume for a deployment.
+     * @param {object} volume - Volume configuration.
+     * @param {string} volume.claimName - Name of the persistent volume claim.
+     * @param {string} volume.volumeMountPath - Mount path of the volume in the container.
+     * @param {string} volume.volumeName - Name of the volume.
+     * @param {object} options - Options for the volume deployment.
+     * @param {string} options.deployId - Deployment ID.
+     * @param {string} options.env - Environment for the deployment.
+     * @param {string} options.version - Version of the deployment.
+     * @param {string} options.namespace - Kubernetes namespace for the deployment.
+     * @param {string} options.nodeName - Node name for the deployment.
+     * @memberof UnderpostDeploy
+     */
+    deployVolume(
+      volume = { claimName: '', volumeMountPath: '', volumeName: '' },
+      options = {
+        deployId: '',
+        env: '',
+        version: '',
+        namespace: '',
+        nodeName: '',
+      },
+    ) {
+      if (!volume.claimName) {
+        logger.warn('Volume claimName is required to deploy volume', volume);
+        return;
+      }
+      const { deployId, env, version, namespace } = options;
+      const pvcId = `${volume.claimName}-${deployId}-${env}-${version}`;
+      const pvId = `${volume.claimName.replace('pvc-', 'pv-')}-${deployId}-${env}-${version}`;
+      const rootVolumeHostPath = `/home/dd/engine/volume/${pvId}`;
+      if (options.nodeName) {
+        if (!fs.existsSync(rootVolumeHostPath)) fs.mkdirSync(rootVolumeHostPath, { recursive: true });
+        fs.copySync(volume.volumeMountPath, rootVolumeHostPath);
+      } else {
+        shellExec(`docker exec -i kind-worker bash -c "mkdir -p ${rootVolumeHostPath}"`);
+        // shellExec(`docker cp ${volume.volumeMountPath} kind-worker:${rootVolumeHostPath}`);
+        shellExec(`tar -C ${volume.volumeMountPath} -c . | docker cp - kind-worker:${rootVolumeHostPath}`);
+        shellExec(
+          `docker exec -i kind-worker bash -c "chown -R 1000:1000 ${rootVolumeHostPath} || true; chmod -R 755 ${rootVolumeHostPath}"`,
+        );
+      }
+      shellExec(`kubectl delete pvc ${pvcId} -n ${namespace} --ignore-not-found`);
+      shellExec(`kubectl delete pv ${pvId} --ignore-not-found`);
+      shellExec(`kubectl apply -f - -n ${namespace} <<EOF
+${UnderpostDeploy.API.persistentVolumeFactory({
+  hostPath: rootVolumeHostPath,
+  pvcId,
+})}
+EOF
+`);
+    },
+
     /**
      * Creates volume mounts and volumes for a deployment.
      * @param {Array<volume>} volumes - List of volume configurations.
@@ -838,19 +888,32 @@ ${renderHosts}`,
      * @param {string} env - Environment for which the ready status is being monitored.
      * @param {string} targetTraffic - Target traffic status for the deployment.
      * @param {Array<string>} ignorePods - List of pod names to ignore.
+     * @returns {object} - Object containing the ready status of the deployment.
      * @memberof UnderpostDeploy
      */
     async monitorReadyRunner(deployId, env, targetTraffic, ignorePods = []) {
       let checkStatusIteration = 0;
       const checkStatusIterationMsDelay = 1000;
+      const maxIterations = 500;
       const iteratorTag = `[${deployId}-${env}-${targetTraffic}]`;
       logger.info('Deployment init', { deployId, env, targetTraffic, checkStatusIterationMsDelay });
       const minReadyOk = 3;
       let readyOk = 0;
+      let result = {
+        ready: false,
+        notReadyPods: [],
+        readyPods: [],
+      };
 
       while (readyOk < minReadyOk) {
-        const ready = UnderpostDeploy.API.checkDeploymentReadyStatus(deployId, env, targetTraffic, ignorePods).ready;
-        if (ready === true) {
+        if (checkStatusIteration >= maxIterations) {
+          logger.error(
+            `${iteratorTag} | Deployment check ready status timeout. Max iterations reached: ${maxIterations}`,
+          );
+          break;
+        }
+        result = UnderpostDeploy.API.checkDeploymentReadyStatus(deployId, env, targetTraffic, ignorePods);
+        if (result.ready === true) {
           readyOk++;
           logger.info(`${iteratorTag} | Deployment ready. Verification number: ${readyOk}`);
         }
@@ -861,6 +924,7 @@ ${renderHosts}`,
         );
       }
       logger.info(`${iteratorTag} | Deployment ready. | Total delay number check iterations: ${checkStatusIteration}`);
+      return result;
     },
 
     /**
@@ -915,6 +979,106 @@ ${renderHosts}`,
       }
       return result;
     },
+
+    /**
+     * Predefined resource templates for Kubernetes deployments.
+     * @memberof UnderpostDeploy
+     */
+    resourcesTemplate: {
+      dev_small: {
+        id: 'dev_small',
+        useCase: 'microservice_development',
+        resources: {
+          requests: {
+            memory: '128Mi',
+            cpu: '250m',
+          },
+          limits: {
+            memory: '512Mi',
+            cpu: '1',
+          },
+        },
+      },
+      prod_moderate: {
+        id: 'prod_moderate',
+        useCase: 'production_moderate',
+        resources: {
+          requests: {
+            memory: '256Mi',
+            cpu: '500m',
+          },
+          limits: {
+            memory: '512Mi',
+            cpu: '1',
+          },
+        },
+      },
+      memory_heavy: {
+        id: 'memory_heavy',
+        useCase: 'memory_intensive_app',
+        resources: {
+          requests: {
+            memory: '512Mi',
+            cpu: '500m',
+          },
+          limits: {
+            memory: '1Gi',
+            cpu: '1',
+          },
+        },
+      },
+      cpu_bound: {
+        id: 'cpu_bound',
+        useCase: 'cpu_intensive_job',
+        resources: {
+          requests: {
+            memory: '256Mi',
+            cpu: '1000m',
+          },
+          limits: {
+            memory: '512Mi',
+            cpu: '2000m',
+          },
+        },
+      },
+    },
+
+    /**
+     * Creates a resource object for Kubernetes deployments.
+     * @param {object} resources - Resource specifications.
+     * @param {string} resources.requestsMemory - Memory request for the container.
+     * @param {string} resources.requestsCpu - CPU request for the container.
+     * @param {string} resources.limitsMemory - Memory limit for the container.
+     * @param {string} resources.limitsCpu - CPU limit for the container.
+     * @returns {object|undefined} - Resource object for Kubernetes deployments or undefined if any resource is missing.
+     * @memberof UnderpostDeploy
+     */
+    resourcesFactory: (
+      resources = {
+        resourceTemplateId: '',
+        requestsMemory: '',
+        requestsCpu: '',
+        limitsMemory: '',
+        limitsCpu: '',
+      },
+    ) => {
+      if (resources) {
+        if (resources.resourceTemplateId)
+          return UnderpostDeploy.API.resourcesTemplate[resources.resourceTemplateId].resources;
+        if (resources.requestsMemory && resources.requestsCpu && resources.limitsMemory && resources.limitsCpu)
+          return {
+            requests: {
+              memory: resources.requestsMemory,
+              cpu: resources.requestsCpu,
+            },
+            limits: {
+              memory: resources.limitsMemory,
+              cpu: resources.limitsCpu,
+            },
+          };
+      }
+      return undefined;
+    },
   };
 }
 

package/src/cli/index.js

@@ -177,8 +177,6 @@ program
   )
   .option('--dev', 'Initializes a development-specific cluster configuration.')
   .option('--list-pods', 'Displays detailed information about all pods.')
-  .option('--info-capacity', 'Displays the current total machine capacity information.')
-  .option('--info-capacity-pod', 'Displays the current machine capacity information per pod.')
   .option('--pull-image', 'Sets an optional associated image to pull during initialization.')
   .option('--init-host', 'Installs necessary Kubernetes node CLI tools (e.g., kind, kubeadm, docker, podman, helm).')
   .option('--uninstall-host', 'Uninstalls all host components installed by init-host.')
@@ -439,6 +437,16 @@ program
   .option('--terminal', 'Enables terminal mode for interactive script execution.')
   .option('--dev-proxy-port-offset <port-offset>', 'Sets a custom port offset for development proxy.')
   .option('--host-network', 'Enables host network mode for the runner execution.')
+  .option('--requests-memory <requests-memory>', 'Requests memory limit for the runner execution.')
+  .option('--requests-cpu <requests-cpu>', 'Requests CPU limit for the runner execution.')
+  .option('--limits-memory <limits-memory>', 'Sets memory limit for the runner execution.')
+  .option('--limits-cpu <limits-cpu>', 'Sets CPU limit for the runner execution.')
+  .option(
+    '--resource-template-id <resource-template-id >',
+    'Specifies a resource template ID for the runner execution.',
+  )
+  .option('--etcHosts', 'Enables /etc/hosts management for the runner execution.')
+  .option('--expose', 'Enables service exposure for the runner execution.')
   .option('--conf-server-path <conf-server-path>', 'Sets a custom configuration server path.')
   .option('--underpost-root <underpost-root>', 'Sets a custom Underpost root path.')
   .description('Runs a script from the specified path.')

package/src/cli/monitor.js

@@ -75,7 +75,7 @@ class UnderpostMonitor {
 
       let errorPayloads = [];
       if (options.sync === true) {
-        const currentTraffic = UnderpostDeploy.API.getCurrentTraffic(deployId);
+        const currentTraffic = UnderpostDeploy.API.getCurrentTraffic(deployId, { namespace: options.namespace });
         if (currentTraffic) UnderpostRootEnv.API.set(`${deployId}-${env}-traffic`, currentTraffic);
       }
       let traffic = UnderpostRootEnv.API.get(`${deployId}-${env}-traffic`) ?? 'blue';