Vidya reddy/prettier code (#203)

This commit is contained in:
Vidya
2022-06-24 13:57:45 -07:00
committed by GitHub
parent 976c5c4981
commit dcd9bc6b1a
71 changed files with 16044 additions and 15876 deletions
+74 -74
View File
@@ -1,85 +1,85 @@
import * as core from "@actions/core";
import * as models from "../types/kubernetesTypes";
import * as KubernetesConstants from "../types/kubernetesTypes";
import { Kubectl, Resource } from "../types/kubectl";
import * as core from '@actions/core'
import * as models from '../types/kubernetesTypes'
import * as KubernetesConstants from '../types/kubernetesTypes'
import {Kubectl, Resource} from '../types/kubectl'
import {
getResources,
updateManifestFiles,
} from "../utilities/manifestUpdateUtils";
import { routeBlueGreen } from "../strategyHelpers/blueGreen/blueGreenHelper";
getResources,
updateManifestFiles
} from '../utilities/manifestUpdateUtils'
import {routeBlueGreen} from '../strategyHelpers/blueGreen/blueGreenHelper'
import {
annotateAndLabelResources,
checkManifestStability,
deployManifests,
} from "../strategyHelpers/deploymentHelper";
import { DeploymentStrategy } from "../types/deploymentStrategy";
import { parseTrafficSplitMethod } from "../types/trafficSplitMethod";
import { parseRouteStrategy } from "../types/routeStrategy";
annotateAndLabelResources,
checkManifestStability,
deployManifests
} from '../strategyHelpers/deploymentHelper'
import {DeploymentStrategy} from '../types/deploymentStrategy'
import {parseTrafficSplitMethod} from '../types/trafficSplitMethod'
import {parseRouteStrategy} from '../types/routeStrategy'
export async function deploy(
kubectl: Kubectl,
manifestFilePaths: string[],
deploymentStrategy: DeploymentStrategy
kubectl: Kubectl,
manifestFilePaths: string[],
deploymentStrategy: DeploymentStrategy
) {
// update manifests
const inputManifestFiles: string[] = updateManifestFiles(manifestFilePaths);
core.debug("Input manifest files: " + inputManifestFiles);
// update manifests
const inputManifestFiles: string[] = updateManifestFiles(manifestFilePaths)
core.debug('Input manifest files: ' + inputManifestFiles)
// deploy manifests
core.info("Deploying manifests");
const trafficSplitMethod = parseTrafficSplitMethod(
core.getInput("traffic-split-method", { required: true })
);
const deployedManifestFiles = await deployManifests(
inputManifestFiles,
deploymentStrategy,
kubectl,
trafficSplitMethod
);
core.debug("Deployed manifest files: " + deployedManifestFiles);
// deploy manifests
core.info('Deploying manifests')
const trafficSplitMethod = parseTrafficSplitMethod(
core.getInput('traffic-split-method', {required: true})
)
const deployedManifestFiles = await deployManifests(
inputManifestFiles,
deploymentStrategy,
kubectl,
trafficSplitMethod
)
core.debug('Deployed manifest files: ' + deployedManifestFiles)
// check manifest stability
core.info("Checking manifest stability");
const resourceTypes: Resource[] = getResources(
deployedManifestFiles,
models.DEPLOYMENT_TYPES.concat([
KubernetesConstants.DiscoveryAndLoadBalancerResource.SERVICE,
])
);
await checkManifestStability(kubectl, resourceTypes);
// check manifest stability
core.info('Checking manifest stability')
const resourceTypes: Resource[] = getResources(
deployedManifestFiles,
models.DEPLOYMENT_TYPES.concat([
KubernetesConstants.DiscoveryAndLoadBalancerResource.SERVICE
])
)
await checkManifestStability(kubectl, resourceTypes)
if (deploymentStrategy == DeploymentStrategy.BLUE_GREEN) {
core.info("Routing blue green");
const routeStrategy = parseRouteStrategy(
core.getInput("route-method", { required: true })
);
await routeBlueGreen(kubectl, inputManifestFiles, routeStrategy);
}
if (deploymentStrategy == DeploymentStrategy.BLUE_GREEN) {
core.info('Routing blue green')
const routeStrategy = parseRouteStrategy(
core.getInput('route-method', {required: true})
)
await routeBlueGreen(kubectl, inputManifestFiles, routeStrategy)
}
// print ingresses
core.info("Printing ingresses");
const ingressResources: Resource[] = getResources(deployedManifestFiles, [
KubernetesConstants.DiscoveryAndLoadBalancerResource.INGRESS,
]);
for (const ingressResource of ingressResources) {
await kubectl.getResource(
KubernetesConstants.DiscoveryAndLoadBalancerResource.INGRESS,
ingressResource.name
);
}
// print ingresses
core.info('Printing ingresses')
const ingressResources: Resource[] = getResources(deployedManifestFiles, [
KubernetesConstants.DiscoveryAndLoadBalancerResource.INGRESS
])
for (const ingressResource of ingressResources) {
await kubectl.getResource(
KubernetesConstants.DiscoveryAndLoadBalancerResource.INGRESS,
ingressResource.name
)
}
// annotate resources
core.info("Annotating resources");
let allPods;
try {
allPods = JSON.parse((await kubectl.getAllPods()).stdout);
} catch (e) {
core.debug("Unable to parse pods: " + e);
}
await annotateAndLabelResources(
deployedManifestFiles,
kubectl,
resourceTypes,
allPods
);
// annotate resources
core.info('Annotating resources')
let allPods
try {
allPods = JSON.parse((await kubectl.getAllPods()).stdout)
} catch (e) {
core.debug('Unable to parse pods: ' + e)
}
await annotateAndLabelResources(
deployedManifestFiles,
kubectl,
resourceTypes,
allPods
)
}
+173 -172
View File
@@ -1,172 +1,173 @@
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
);
}
}
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
)
}
}
+68 -68
View File
@@ -1,68 +1,68 @@
import * as core from "@actions/core";
import * as canaryDeploymentHelper from "../strategyHelpers/canary/canaryHelper";
import * as SMICanaryDeploymentHelper from "../strategyHelpers/canary/smiCanaryHelper";
import { Kubectl } from "../types/kubectl";
import { rejectBlueGreenService } from "../strategyHelpers/blueGreen/serviceBlueGreenHelper";
import { rejectBlueGreenIngress } from "../strategyHelpers/blueGreen/ingressBlueGreenHelper";
import { rejectBlueGreenSMI } from "../strategyHelpers/blueGreen/smiBlueGreenHelper";
import { DeploymentStrategy } from "../types/deploymentStrategy";
import {
parseTrafficSplitMethod,
TrafficSplitMethod,
} from "../types/trafficSplitMethod";
import { parseRouteStrategy, RouteStrategy } from "../types/routeStrategy";
export async function reject(
kubectl: Kubectl,
manifests: string[],
deploymentStrategy: DeploymentStrategy
) {
switch (deploymentStrategy) {
case DeploymentStrategy.CANARY:
await rejectCanary(kubectl, manifests);
break;
case DeploymentStrategy.BLUE_GREEN:
await rejectBlueGreen(kubectl, manifests);
break;
default:
throw "Invalid delete deployment strategy";
}
}
async function rejectCanary(kubectl: Kubectl, manifests: string[]) {
let includeServices = false;
const trafficSplitMethod = parseTrafficSplitMethod(
core.getInput("traffic-split-method", { required: true })
);
if (trafficSplitMethod == TrafficSplitMethod.SMI) {
core.info("Rejecting deployment with SMI canary strategy");
includeServices = true;
await SMICanaryDeploymentHelper.redirectTrafficToStableDeployment(
kubectl,
manifests
);
}
core.info("Deleting baseline and canary workloads");
await canaryDeploymentHelper.deleteCanaryDeployment(
kubectl,
manifests,
includeServices
);
}
async function rejectBlueGreen(kubectl: Kubectl, manifests: string[]) {
core.info("Rejecting deployment with blue green strategy");
const routeStrategy = parseRouteStrategy(
core.getInput("route-method", { required: true })
);
if (routeStrategy == RouteStrategy.INGRESS) {
await rejectBlueGreenIngress(kubectl, manifests);
} else if (routeStrategy == RouteStrategy.SMI) {
await rejectBlueGreenSMI(kubectl, manifests);
} else {
await rejectBlueGreenService(kubectl, manifests);
}
}
import * as core from '@actions/core'
import * as canaryDeploymentHelper from '../strategyHelpers/canary/canaryHelper'
import * as SMICanaryDeploymentHelper from '../strategyHelpers/canary/smiCanaryHelper'
import {Kubectl} from '../types/kubectl'
import {rejectBlueGreenService} from '../strategyHelpers/blueGreen/serviceBlueGreenHelper'
import {rejectBlueGreenIngress} from '../strategyHelpers/blueGreen/ingressBlueGreenHelper'
import {rejectBlueGreenSMI} from '../strategyHelpers/blueGreen/smiBlueGreenHelper'
import {DeploymentStrategy} from '../types/deploymentStrategy'
import {
parseTrafficSplitMethod,
TrafficSplitMethod
} from '../types/trafficSplitMethod'
import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
export async function reject(
kubectl: Kubectl,
manifests: string[],
deploymentStrategy: DeploymentStrategy
) {
switch (deploymentStrategy) {
case DeploymentStrategy.CANARY:
await rejectCanary(kubectl, manifests)
break
case DeploymentStrategy.BLUE_GREEN:
await rejectBlueGreen(kubectl, manifests)
break
default:
throw 'Invalid delete deployment strategy'
}
}
async function rejectCanary(kubectl: Kubectl, manifests: string[]) {
let includeServices = false
const trafficSplitMethod = parseTrafficSplitMethod(
core.getInput('traffic-split-method', {required: true})
)
if (trafficSplitMethod == TrafficSplitMethod.SMI) {
core.info('Rejecting deployment with SMI canary strategy')
includeServices = true
await SMICanaryDeploymentHelper.redirectTrafficToStableDeployment(
kubectl,
manifests
)
}
core.info('Deleting baseline and canary workloads')
await canaryDeploymentHelper.deleteCanaryDeployment(
kubectl,
manifests,
includeServices
)
}
async function rejectBlueGreen(kubectl: Kubectl, manifests: string[]) {
core.info('Rejecting deployment with blue green strategy')
const routeStrategy = parseRouteStrategy(
core.getInput('route-method', {required: true})
)
if (routeStrategy == RouteStrategy.INGRESS) {
await rejectBlueGreenIngress(kubectl, manifests)
} else if (routeStrategy == RouteStrategy.SMI) {
await rejectBlueGreenSMI(kubectl, manifests)
} else {
await rejectBlueGreenService(kubectl, manifests)
}
}