k8s-deploy/src/actions/promote.ts

import * as core from "@actions/core";
import * as deploy from "./deploy";
import * as canaryDeploymentHelper from "../strategyHelpers/canary/canaryHelper";
import * as SMICanaryDeploymentHelper from "../strategyHelpers/canary/smiCanaryHelper";
import {
  getResources,
  updateManifestFiles,
} from "../utilities/manifestUpdateUtils";
import * as models from "../types/kubernetesTypes";
import * as KubernetesManifestUtility from "../utilities/manifestStabilityUtils";
import {
  BlueGreenManifests,
  deleteWorkloadsAndServicesWithLabel,
  deleteWorkloadsWithLabel,
  getManifestObjects,
  GREEN_LABEL_VALUE,
  NONE_LABEL_VALUE,
} from "../strategyHelpers/blueGreen/blueGreenHelper";
import {
  promoteBlueGreenService,
  routeBlueGreenService,
} from "../strategyHelpers/blueGreen/serviceBlueGreenHelper";
import {
  promoteBlueGreenIngress,
  routeBlueGreenIngress,
} from "../strategyHelpers/blueGreen/ingressBlueGreenHelper";
import {
  cleanupSMI,
  promoteBlueGreenSMI,
  routeBlueGreenSMI,
} from "../strategyHelpers/blueGreen/smiBlueGreenHelper";
import { Kubectl, Resource } from "../types/kubectl";
import { DeploymentStrategy } from "../types/deploymentStrategy";
import {
  parseTrafficSplitMethod,
  TrafficSplitMethod,
} from "../types/trafficSplitMethod";
import { parseRouteStrategy, RouteStrategy } from "../types/routeStrategy";

export async function promote(
  kubectl: Kubectl,
  manifests: string[],
  deploymentStrategy: DeploymentStrategy
) {
  switch (deploymentStrategy) {
    case DeploymentStrategy.CANARY:
      await promoteCanary(kubectl, manifests);
      break;
    case DeploymentStrategy.BLUE_GREEN:
      await promoteBlueGreen(kubectl, manifests);
      break;
    default:
      throw Error("Invalid promote deployment strategy");
  }
}

async function promoteCanary(kubectl: Kubectl, manifests: string[]) {
  let includeServices = false;

  const trafficSplitMethod = parseTrafficSplitMethod(
    core.getInput("traffic-split-method", { required: true })
  );
  if (trafficSplitMethod == TrafficSplitMethod.SMI) {
    includeServices = true;

    // In case of SMI traffic split strategy when deployment is promoted, first we will redirect traffic to
    // canary deployment, then update stable deployment and then redirect traffic to stable deployment
    core.info("Redirecting traffic to canary deployment");
    await SMICanaryDeploymentHelper.redirectTrafficToCanaryDeployment(
      kubectl,
      manifests
    );

    core.info("Deploying input manifests with SMI canary strategy");
    await deploy.deploy(kubectl, manifests, DeploymentStrategy.CANARY);

    core.info("Redirecting traffic to stable deployment");
    await SMICanaryDeploymentHelper.redirectTrafficToStableDeployment(
      kubectl,
      manifests
    );
  } else {
    core.info("Deploying input manifests");
    await deploy.deploy(kubectl, manifests, DeploymentStrategy.CANARY);
  }

  core.info("Deleting canary and baseline workloads");
  try {
    await canaryDeploymentHelper.deleteCanaryDeployment(
      kubectl,
      manifests,
      includeServices
    );
  } catch (ex) {
    core.warning(
      "Exception occurred while deleting canary and baseline workloads: " + ex
    );
  }
}

async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
  // update container images and pull secrets
  const inputManifestFiles: string[] = updateManifestFiles(manifests);
  const manifestObjects: BlueGreenManifests =
    getManifestObjects(inputManifestFiles);

  const routeStrategy = parseRouteStrategy(
    core.getInput("route-method", { required: true })
  );

  core.info("Deleting old deployment and making new one");
  let result;
  if (routeStrategy == RouteStrategy.INGRESS) {
    result = await promoteBlueGreenIngress(kubectl, manifestObjects);
  } else if (routeStrategy == RouteStrategy.SMI) {
    result = await promoteBlueGreenSMI(kubectl, manifestObjects);
  } else {
    result = await promoteBlueGreenService(kubectl, manifestObjects);
  }

  // checking stability of newly created deployments
  core.info("Checking manifest stability");
  const deployedManifestFiles = result.newFilePaths;
  const resources: Resource[] = getResources(
    deployedManifestFiles,
    models.DEPLOYMENT_TYPES.concat([
      models.DiscoveryAndLoadBalancerResource.SERVICE,
    ])
  );
  await KubernetesManifestUtility.checkManifestStability(kubectl, resources);

  core.info(
    "Routing to new deployments and deleting old workloads and services"
  );
  if (routeStrategy == RouteStrategy.INGRESS) {
    await routeBlueGreenIngress(
      kubectl,
      null,
      manifestObjects.serviceNameMap,
      manifestObjects.ingressEntityList
    );
    await deleteWorkloadsAndServicesWithLabel(
      kubectl,
      GREEN_LABEL_VALUE,
      manifestObjects.deploymentEntityList,
      manifestObjects.serviceEntityList
    );
  } else if (routeStrategy == RouteStrategy.SMI) {
    await routeBlueGreenSMI(
      kubectl,
      NONE_LABEL_VALUE,
      manifestObjects.serviceEntityList
    );
    await deleteWorkloadsWithLabel(
      kubectl,
      GREEN_LABEL_VALUE,
      manifestObjects.deploymentEntityList
    );
    await cleanupSMI(kubectl, manifestObjects.serviceEntityList);
  } else {
    await routeBlueGreenService(
      kubectl,
      NONE_LABEL_VALUE,
      manifestObjects.serviceEntityList
    );
    await deleteWorkloadsWithLabel(
      kubectl,
      GREEN_LABEL_VALUE,
      manifestObjects.deploymentEntityList
    );
  }
}