@axinom/mosaic-cli 0.20.0-rc.9 → 0.20.0

package/src/commands/hosting/pilet/register-pilet.ts

@@ -1,4 +1,4 @@
-import { getServiceAccountToken } from '@axinom/mosaic-id-link-be';
+import { TokenResult, getServiceAccountToken } from '@axinom/mosaic-id-link-be';
 import { isNullOrWhitespace } from '@axinom/mosaic-service-common';
 import axios, { AxiosError } from 'axios';
 import * as FormData from 'form-data';
@@ -9,11 +9,30 @@ import { GetRegisterPiletOptions } from './register-pilet-options';
 export const registerPilet = async (
   args: Required<GetRegisterPiletOptions>,
 ): Promise<void> => {
-  const serviceAccountToken = await getServiceAccountToken(
-    args.idServiceAuthBaseURL,
-    args.mosaicHostingClientId,
-    args.mosaicHostingClientSecret,
-  );
+  let serviceAccountToken: TokenResult | undefined;
+
+  try {
+    serviceAccountToken = await getServiceAccountToken(
+      args.idServiceAuthBaseURL,
+      args.mosaicHostingClientId,
+      args.mosaicHostingClientSecret,
+    );
+  } catch (error) {
+    console.log(
+      `\nFailed to get the service account token. ${
+        (error as Error).message
+      }\n`,
+    );
+    return;
+  }
+
+  // Extract the tenant/environment IDs from the access token
+  const { tenantId, environmentId } = JSON.parse(
+    Buffer.from(
+      serviceAccountToken.accessToken.split('.')[1],
+      'base64',
+    ).toString(),
+  ) as { tenantId: string; environmentId: string };
 
   const data = new FormData();
 
@@ -27,20 +46,21 @@ export const registerPilet = async (
 
   try {
     const artifactToPublish = findArtifactToPublish(args.piletArtifactPath);
-    if (artifactToPublish) {
-      data.append('', createReadStream(artifactToPublish));
-    } else {
-      throw new Error(`No Pilet Artifact found at ${args.piletArtifactPath}.`);
-    }
+    data.append('', createReadStream(artifactToPublish));
   } catch (error) {
-    throw new Error(
-      `Error occurred while trying to read the Pilet Artifact at ${args.piletArtifactPath}.`,
-    );
+    console.log(`\n${(error as Error).message}`);
+    return;
   }
 
   try {
+    console.log(`\nRegistering pilet...`);
+    console.log(`path:\t\t${args.piletArtifactPath}`);
+    console.log(`tenantId:\t${tenantId}`);
+    console.log(`environmentId:\t${environmentId}`);
+    console.log(`serviceId:\t${args.serviceId}\n`);
+
     const result = await axios.post(
-      `${args.microFrontendServiceBaseURL}/v1/pilets/${args.tenantId}/${args.environmentId}/${args.serviceId}/register?override=${args.overrideRegistration}`,
+      `${args.microFrontendServiceBaseURL}/v1/pilets/${tenantId}/${environmentId}/${args.serviceId}/register?override=${args.overrideRegistration}`,
       data,
       config,
     );
@@ -52,6 +72,7 @@ export const registerPilet = async (
       'Registration of Pilet failed.',
       (error as AxiosError).response?.data ?? (error as Error).message,
     );
+    return;
   }
 };
 
@@ -64,82 +85,93 @@ export const registerPilet = async (
  */
 export const validateArgs = (
   args: GetRegisterPiletOptions,
-): Required<GetRegisterPiletOptions> => {
+): [Required<GetRegisterPiletOptions>, string[]] => {
+  const errorMessages: string[] = [];
+
   const idServiceAuthBaseURL =
-    args.idServiceAuthBaseURL ?? process.env.ID_SERVICE_AUTH_BASE_URL;
+    args.idServiceAuthBaseURL ?? process.env.ID_SERVICE_AUTH_BASE_URL ?? '';
   const mosaicHostingClientId =
-    args.mosaicHostingClientId ?? process.env.MOSAIC_HOSTING_CLIENT_ID;
+    args.mosaicHostingClientId ?? process.env.MOSAIC_HOSTING_CLIENT_ID ?? '';
   const mosaicHostingClientSecret =
-    args.mosaicHostingClientSecret ?? process.env.MOSAIC_HOSTING_CLIENT_SECRET;
-  const tenantId = args.tenantId ?? process.env.TENANT_ID;
-  const environmentId = args.environmentId ?? process.env.ENVIRONMENT_ID;
-  const serviceId = args.serviceId ?? process.env.SERVICE_ID;
-  const piletArtifactPath = args.piletArtifactPath ?? process.env.PILET_PATH;
+    args.mosaicHostingClientSecret ??
+    process.env.MOSAIC_HOSTING_CLIENT_SECRET ??
+    '';
+  const serviceId = args.serviceId ?? process.env.SERVICE_ID ?? '';
+  const piletArtifactPath =
+    args.piletArtifactPath ?? process.env.PILET_PATH ?? '';
   const microFrontendServiceBaseURL =
     args.microFrontendServiceBaseURL ??
-    process.env.MICRO_FRONTEND_SERVICE_BASE_URL;
+    process.env.MICRO_FRONTEND_SERVICE_BASE_URL ??
+    '';
 
   if (isNullOrWhitespace(idServiceAuthBaseURL)) {
-    throw new Error('idServiceAuthBaseURL is required.');
+    errorMessages.push('[idServiceAuthBaseURL] is required.');
   }
   if (isNullOrWhitespace(mosaicHostingClientId)) {
-    throw new Error('clientId is required.');
+    errorMessages.push('[clientId] is required.');
   }
   if (isNullOrWhitespace(mosaicHostingClientSecret)) {
-    throw new Error('clientSecret is required.');
-  }
-  if (isNullOrWhitespace(tenantId)) {
-    throw new Error('tenantId is required.');
-  }
-  if (isNullOrWhitespace(environmentId)) {
-    throw new Error('environmentId is required,');
+    errorMessages.push('[clientSecret] is required.');
   }
   if (isNullOrWhitespace(serviceId)) {
-    throw new Error('serviceId is required.');
+    errorMessages.push('[serviceId] is required.');
   }
   if (isNullOrWhitespace(piletArtifactPath)) {
-    throw new Error('piletArtifactPath is required,');
+    errorMessages.push('[piletArtifactPath] is required,');
   }
   if (isNullOrWhitespace(microFrontendServiceBaseURL)) {
-    throw new Error('microFrontendServiceBaseURL is required.');
+    errorMessages.push('[microFrontendServiceBaseURL] is required.');
   }
 
-  return {
-    idServiceAuthBaseURL,
-    mosaicHostingClientId,
-    mosaicHostingClientSecret,
-    tenantId,
-    environmentId,
-    serviceId,
-    piletArtifactPath,
-    microFrontendServiceBaseURL,
-    overrideRegistration: args.overrideRegistration ?? false,
-  };
+  return [
+    {
+      idServiceAuthBaseURL,
+      mosaicHostingClientId,
+      mosaicHostingClientSecret,
+      serviceId,
+      piletArtifactPath,
+      microFrontendServiceBaseURL,
+      overrideRegistration: args.overrideRegistration ?? false,
+    },
+    errorMessages,
+  ];
 };
 
-const findArtifactToPublish = (piletPath: string): string | undefined => {
+const findArtifactToPublish = (piletPath: string): string => {
   if (!existsSync(piletPath)) {
-    throw new Error(`No directory found at ${piletPath}`);
+    throw new Error(
+      `The specified pilet artifact path [${piletPath}] does not exist.`,
+    );
   }
 
-  const files = readdirSync(piletPath);
   const tgzFiles: string[] = [];
 
-  for (let i = 0; i < files.length; i++) {
-    const filename = path.join(piletPath, files[i]);
-    const stat = lstatSync(filename);
-    if (!stat.isDirectory() && filename.endsWith('.tgz')) {
-      tgzFiles.push(filename);
+  // Is the path a directory?
+  if (lstatSync(piletPath).isDirectory()) {
+    const files = readdirSync(piletPath);
+
+    for (let i = 0; i < files.length; i++) {
+      const filename = path.join(piletPath, files[i]);
+      const stat = lstatSync(filename);
+      if (!stat.isDirectory() && filename.endsWith('.tgz')) {
+        tgzFiles.push(filename);
+      }
     }
+  } // Path is a file
+  else {
+    tgzFiles.push(piletPath);
   }
 
   if (tgzFiles.length > 1) {
     throw new Error(
-      `Found more than one .tgz files in the folder ${piletPath}. Please make sure only one .tgz file exists`,
+      `Found more than one .tgz files in the folder [${piletPath}]. Please make sure only one .tgz file exists or specify the path to the .tgz file.`,
     );
   }
+
   if (tgzFiles.length === 0) {
-    throw new Error(`'No .tgz files found at ${piletPath}.`);
+    throw new Error(
+      `No .tgz files found at pilet artifact path [${piletPath}].`,
+    );
   }
 
   return tgzFiles[0];

package/src/commands/hosting/service/deploy/service-deploy-command.ts

@@ -0,0 +1,72 @@
+import { red, yellow } from 'chalk';
+import { CommandModule } from 'yargs';
+import { deployService, validateDeploymentArgs } from './service-deploy';
+import { GetServiceDeployOptions } from './service-deploy-options';
+
+export const serviceDeploy: CommandModule<unknown, GetServiceDeployOptions> = {
+  builder: (yargs) => {
+    return yargs
+      .option('name', {
+        describe: 'Name of the Deployment',
+        alias: 'n',
+        string: true,
+        demandOption: true,
+      })
+      .option('serviceId', {
+        describe:
+          'Service ID the deployment must be done for. (If a deployment manifest is found in the current directory, the serviceId will be derived from it.)',
+        alias: 'i',
+        string: true,
+      })
+      .option('containerImageTag', {
+        describe:
+          'Tag of the container image to be used in the deployment. i.e: It should be the <tag> from the container image format <username>/<repository_name>:<tag>.',
+        alias: 't',
+        string: true,
+        demandOption: true,
+      })
+      .option('manifestName', {
+        describe: 'Name of the deployment manifest',
+        alias: 'm',
+        string: true,
+        demandOption: true,
+      })
+      .option('pilets', {
+        describe:
+          'Pilet(s) to be used in the deployment. The pilet name should match the format package-name@version => media-workflows@1.5.7',
+        alias: 'p',
+        array: true,
+        string: true,
+      })
+      .option('mosaicHostingClientId', {
+        describe: 'Service Account Client ID to authenticate',
+        alias: 'c',
+        string: true,
+      })
+      .option('mosaicHostingClientSecret', {
+        describe: 'Service Account Client Secret to authenticate',
+        alias: 's',
+        string: true,
+      })
+      .option('idServiceAuthBaseURL', {
+        describe: 'ID Service Authentication Endpoint Base URL',
+        alias: 'a',
+        string: true,
+      })
+      .option('hostingServiceBaseURL', {
+        describe: 'Hosting Service Base URL',
+        alias: 'h',
+        string: true,
+      });
+  },
+  handler: async (args) => {
+    const [validatedArgs, errorMessages] = validateDeploymentArgs(args);
+    if (errorMessages.length > 0) {
+      console.log(red('Some required arguments are missing.'));
+      console.log(yellow(errorMessages));
+      console.log();
+    } else {
+      await deployService(validatedArgs);
+    }
+  },
+};

package/src/commands/hosting/service/deploy/service-deploy-options.ts

@@ -0,0 +1,14 @@
+/**
+ * Options for Deploying a Service
+ */
+export interface GetServiceDeployOptions {
+  name: string;
+  serviceId?: string;
+  containerImageTag: string;
+  manifestName: string;
+  pilets?: string[];
+  mosaicHostingClientId?: string;
+  mosaicHostingClientSecret?: string;
+  idServiceAuthBaseURL?: string;
+  hostingServiceBaseURL?: string;
+}

package/src/commands/hosting/service/deploy/service-deploy.ts

@@ -0,0 +1,347 @@
+import { getServiceAccountToken } from '@axinom/mosaic-id-link-be';
+import { isNullOrWhitespace } from '@axinom/mosaic-service-common';
+import axios, { AxiosError, AxiosInstance } from 'axios';
+import { green, red, yellow } from 'chalk';
+import { readFileSync } from 'fs';
+import * as yaml from 'js-yaml';
+import { GetServiceDeployOptions } from './service-deploy-options';
+
+const getAxiosInstance = (
+  hostingServiceBaseUrl: string,
+  serviceAccountToken: string,
+): AxiosInstance => {
+  return axios.create({
+    baseURL: new URL(hostingServiceBaseUrl).toString(),
+    headers: {
+      Authorization: `Bearer ${serviceAccountToken}`,
+      'content-type': 'application/json',
+    },
+  });
+};
+
+export const deployService = async (
+  args: Required<GetServiceDeployOptions>,
+): Promise<void> => {
+  const serviceAccountToken = await getServiceAccountToken(
+    args.idServiceAuthBaseURL,
+    args.mosaicHostingClientId,
+    args.mosaicHostingClientSecret,
+  );
+
+  const axiosInstance: AxiosInstance = getAxiosInstance(
+    args.hostingServiceBaseURL,
+    serviceAccountToken.accessToken,
+  );
+
+  const deploymentDetails = await retrieveServiceDeploymentDetails(
+    args,
+    axiosInstance,
+  );
+
+  if (deploymentDetails === undefined) {
+    return;
+  }
+
+  const serviceDeployment = JSON.stringify({
+    query: `mutation initiateServiceDeployment($serviceDefinitionId: UUID!, $containerImageVersion: String!, $serviceDeploymentConfigurationId: UUID!, $servicePiletArtifactIds: [UUID!]!, $name: String) {
+      initiateServiceDeployment(
+        input: {serviceDefinitionId: $serviceDefinitionId, containerImageVersion: $containerImageVersion, serviceDeploymentConfigurationId: $serviceDeploymentConfigurationId, servicePiletArtifactIds: $servicePiletArtifactIds, name: $name}
+      ) {
+        serviceDeploymentId
+        name
+        status
+      }
+  }`,
+    variables: {
+      serviceDefinitionId: deploymentDetails.serviceDefinitionId,
+      containerImageVersion: args.containerImageTag,
+      serviceDeploymentConfigurationId: deploymentDetails.deploymentManifestId,
+      servicePiletArtifactIds: deploymentDetails.piletArtifactIds ?? [],
+      name: args.name,
+    },
+  });
+
+  try {
+    const response = await axiosInstance.post('graphql', serviceDeployment);
+    if (response.data.errors !== undefined && response.data.errors.length > 0) {
+      console.log(red(`Deployment for Service ID [${args.serviceId}] failed.`));
+      if (
+        response.data.errors[0].message ===
+        'Attempt to create or update an element failed, as it would have resulted in a duplicate element.'
+      ) {
+        console.log(
+          yellow(
+            `Hint: The deployment likely failed because the deployment name [${args.name}] is already in use. Please try with a different name.`,
+          ),
+        );
+      } else {
+        console.log(red(response.data.errors[0].message));
+      }
+      console.log();
+    } else {
+      console.log(
+        green(
+          `Deployment for Service ID [${args.serviceId}] initiated successfully. It may take some time to complete the deployment.`,
+        ),
+      );
+      console.log(
+        yellow(JSON.stringify(response.data.data?.initiateServiceDeployment)),
+      );
+      console.log();
+    }
+  } catch (error) {
+    console.log(
+      red(
+        `Error while performing deployment for Service ID [${args.serviceId}].`,
+      ),
+    );
+    console.log(red(JSON.stringify((error as AxiosError).message)));
+  }
+};
+
+/**
+ * Validate arguments for Service Deployment
+ *
+ * @param args
+ * @returns
+ */
+export const validateDeploymentArgs = (
+  args: GetServiceDeployOptions,
+): [Required<GetServiceDeployOptions>, string[]] => {
+  const errorMessages: string[] = [];
+
+  const idServiceAuthBaseURL =
+    args.idServiceAuthBaseURL ?? process.env.ID_SERVICE_AUTH_BASE_URL ?? '';
+  const mosaicHostingClientId =
+    args.mosaicHostingClientId ?? process.env.MOSAIC_HOSTING_CLIENT_ID ?? '';
+  const mosaicHostingClientSecret =
+    args.mosaicHostingClientSecret ??
+    process.env.MOSAIC_HOSTING_CLIENT_SECRET ??
+    '';
+  const serviceId = args.serviceId ?? getServiceIdFromManifest() ?? '';
+  const hostingServiceBaseURL =
+    args.hostingServiceBaseURL ?? process.env.HOSTING_SERVICE_BASE_URL ?? '';
+
+  const manifestName = args.manifestName;
+  const containerImageTag = args.containerImageTag;
+  let pilets = args.pilets;
+
+  if (isNullOrWhitespace(idServiceAuthBaseURL)) {
+    errorMessages.push('[idServiceAuthBaseURL] is required.');
+  }
+  if (isNullOrWhitespace(mosaicHostingClientId)) {
+    errorMessages.push('[clientId] is required.');
+  }
+  if (isNullOrWhitespace(mosaicHostingClientSecret)) {
+    errorMessages.push('[clientSecret] is required.');
+  }
+  if (isNullOrWhitespace(serviceId)) {
+    errorMessages.push(
+      '[serviceId] is required. If no serviceId is given through arguments, mosaic-hosting-deployment-manifest.yaml file in the current directory is checked to derive the serviceId.',
+    );
+  }
+  if (isNullOrWhitespace(hostingServiceBaseURL)) {
+    errorMessages.push('[hostingServiceBaseURL] is required.');
+  }
+  if (isNullOrWhitespace(manifestName)) {
+    errorMessages.push(
+      '[manifestName] is required and cannot be an empty string.',
+    );
+  }
+  if (isNullOrWhitespace(containerImageTag)) {
+    errorMessages.push(
+      '[containerImageTag] is required and cannot be an empty string.',
+    );
+  }
+
+  if (isNullOrWhitespace(pilets)) {
+    pilets = [];
+  }
+
+  return [
+    {
+      name: args.name,
+      idServiceAuthBaseURL,
+      mosaicHostingClientId,
+      mosaicHostingClientSecret,
+      serviceId,
+      manifestName,
+      pilets,
+      containerImageTag: containerImageTag,
+      hostingServiceBaseURL,
+    },
+    errorMessages,
+  ];
+};
+
+const getServiceIdFromManifest = (): string | undefined => {
+  try {
+    const doc = yaml.load(
+      readFileSync('./mosaic-hosting-deployment-manifest.yaml', 'utf8'),
+    );
+    if (!isNullOrWhitespace(doc)) {
+      return (doc as any).serviceId;
+    }
+  } catch (error) {
+    return undefined;
+  }
+};
+
+const retrieveServiceDeploymentDetails = async (
+  args: Required<GetServiceDeployOptions>,
+  axiosInstance: AxiosInstance,
+): Promise<
+  | {
+      serviceDefinitionId: string;
+      deploymentManifestId: string;
+      piletArtifactIds: string[];
+    }
+  | undefined
+> => {
+  const piletNamingErrors: string[] = [];
+
+  const piletFilter = args.pilets.map((pilet) => {
+    const nameAndVersion = pilet.split('@');
+    if (nameAndVersion.length !== 2) {
+      piletNamingErrors.push(`Pilet name [${pilet}] is invalid.`);
+      return;
+    }
+    return {
+      name: { equalTo: nameAndVersion[0] },
+      packageVersion: { equalTo: nameAndVersion[1] },
+      serviceId: { equalTo: args.serviceId },
+    };
+  });
+
+  if (piletNamingErrors.length > 0) {
+    console.log(red(piletNamingErrors));
+    console.log(
+      yellow(
+        `Pilet names must match the pattern [pilet-name@package-version]. i.e.: media-workflows@2.0.1.`,
+      ),
+    );
+    console.log();
+    return;
+  }
+
+  const getDeploymentInfoQuery = `query GetDeploymentInfo($serviceId: String!, $manifestName: String!, $pilets: ServicePiletArtifactFilter ) {
+    serviceDefinitions(condition: {serviceId: $serviceId}) {
+      nodes {
+        id
+      }
+    }
+    serviceDeploymentManifests(
+      filter: {name: {equalTo: $manifestName}, serviceId: {equalTo: $serviceId}}
+    ) {
+      nodes {
+        id
+      }
+    }
+    servicePiletArtifacts(
+      filter: $pilets
+    ) {
+      nodes {
+        id
+      }
+    }
+}`;
+
+  const deploymentInfo = JSON.stringify({
+    query: getDeploymentInfoQuery,
+    variables: {
+      serviceId: args.serviceId,
+      manifestName: args.manifestName,
+      pilets: {
+        and: [{ serviceId: { equalTo: args.serviceId } }, { or: piletFilter }],
+      },
+    },
+  });
+
+  let serviceDefinitionId: string | undefined;
+  let deploymentManifestId: string | undefined;
+  let piletArtifactIds: string[] = [];
+
+  try {
+    const response = await axiosInstance.post('graphql', deploymentInfo);
+    if (response.data.errors !== undefined && response.data.errors.length > 0) {
+      console.log(
+        red(`Error while retrieving deployment info for [${args.serviceId}].`),
+      );
+      console.log(response.data.errors);
+      console.log();
+    } else {
+      serviceDefinitionId =
+        response.data.data?.serviceDefinitions?.nodes[0]?.id;
+      deploymentManifestId =
+        response.data.data?.serviceDeploymentManifests?.nodes[0]?.id;
+      piletArtifactIds = response.data.data?.servicePiletArtifacts?.nodes?.map(
+        (pilet) => pilet.id,
+      );
+      console.log(
+        green(
+          `Deployment info retrieved successfully for [${args.serviceId}].`,
+        ),
+      );
+
+      const joinedPiletArtifactIds = piletArtifactIds?.join(',');
+      console.log(green(`Service Definition ID:\t${serviceDefinitionId}`));
+      console.log(green(`Deployment Manifest ID:\t${deploymentManifestId}`));
+      console.log(
+        green(
+          `Pilet Artifacts ID(s):\t${
+            joinedPiletArtifactIds === ''
+              ? '(No Pilet Artifacts)'
+              : joinedPiletArtifactIds
+          }`,
+        ),
+      );
+
+      console.log();
+    }
+  } catch (error) {
+    console.log(
+      red(`Error while retrieving deployment info for ${args.serviceId}.`),
+    );
+    console.log(JSON.stringify((error as AxiosError).message));
+    console.log();
+  }
+
+  if (isNullOrWhitespace(serviceDefinitionId)) {
+    console.log(
+      red(
+        `No Service Definition found for Service ID [${args.serviceId}]. Cannot proceed with deployment.`,
+      ),
+    );
+    console.log();
+    return;
+  }
+
+  if (isNullOrWhitespace(deploymentManifestId)) {
+    console.log(
+      red(
+        `No Deployment Manifest found for name [${args.manifestName}] and Service ID [${args.serviceId}]. Cannot proceed with deployment.`,
+      ),
+    );
+    console.log();
+    return;
+  }
+
+  if (
+    args.pilets.length > 0 &&
+    args.pilets.length !== piletArtifactIds.length
+  ) {
+    console.log(
+      red(
+        `Pilet artifacts were not found for the given pilet names. Cannot proceed with deployment.`,
+      ),
+    );
+    console.log();
+    return;
+  }
+
+  return {
+    serviceDefinitionId,
+    deploymentManifestId,
+    piletArtifactIds,
+  };
+};

package/src/commands/hosting/service/service-commands.ts

@@ -0,0 +1,23 @@
+import { CommandModule } from 'yargs';
+import { serviceDeploy } from './deploy/service-deploy-command';
+import { serviceUndeploy } from './undeploy/service-undeploy-command';
+
+export const serviceCommands: CommandModule<unknown, unknown> = {
+  builder: (yargs) =>
+    yargs
+      .command(
+        'deploy',
+        'Deploy a service through Hosting Service.',
+        serviceDeploy,
+      )
+      .demandCommand()
+      .command(
+        'undeploy',
+        'Undeploy a service through Hosting Service.',
+        serviceUndeploy,
+      )
+      .demandCommand(),
+  handler: () => {
+    console.log('Please pick an action related to hosting service command.');
+  },
+};