private void updateReplacingReleaseState(Release replacingRelease, boolean rollback) { // Update Status in DB Status status = new Status(); status.setStatusCode(StatusCode.DEPLOYED); replacingRelease.getInfo().setStatus(status); replacingRelease.getInfo().setDescription(rollback ? "Rollback complete" : "Upgrade complete"); this.releaseRepository.save(replacingRelease); logger.info("Release {}-v{} has been DEPLOYED", replacingRelease.getName(), replacingRelease.getVersion()); logger.info("Apps in release {}-v{} are healthy.", replacingRelease.getName(), replacingRelease.getVersion()); }
private Map<String, String> deploy(Release replacingRelease, List<String> applicationNamesToUpgrade, AppDeployer appDeployer) { List<? extends SpringCloudDeployerApplicationManifest> applicationSpecList = this.applicationManifestReader .read(replacingRelease .getManifest().getData()); Map<String, String> appNameDeploymentIdMap = new HashMap<>(); for (SpringCloudDeployerApplicationManifest applicationManifest : applicationSpecList) { if (applicationNamesToUpgrade.contains(applicationManifest.getApplicationName())) { AppDeploymentRequest appDeploymentRequest = appDeploymentRequestFactory.createAppDeploymentRequest( applicationManifest, replacingRelease.getName(), String.valueOf(replacingRelease.getVersion())); // ============= // DEPLOY DEPLOY // ============= String deploymentId = appDeployer.deploy(appDeploymentRequest); appNameDeploymentIdMap.put(applicationManifest.getApplicationName(), deploymentId); } } return appNameDeploymentIdMap; } }
public boolean isHealthy(Release replacingRelease) { AppDeployerData replacingAppDeployerData = this.appDeployerDataRepository .findByReleaseNameAndReleaseVersionRequired( replacingRelease.getName(), replacingRelease.getVersion()); Map<String, String> appNamesAndDeploymentIds = replacingAppDeployerData.getDeploymentDataAsMap(); AppDeployer appDeployer = this.deployerRepository .findByNameRequired(replacingRelease.getPlatformName()) .getAppDeployer(); logger.debug("Getting status for apps in replacing release {}-v{}", replacingRelease.getName(), replacingRelease.getVersion()); for (Map.Entry<String, String> appNameAndDeploymentId : appNamesAndDeploymentIds.entrySet()) { AppStatus status = appDeployer.status(appNameAndDeploymentId.getValue()); if (status.getState() == DeploymentState.deployed) { return true; } } return false; } }
/** * @return a textual summary of the ReleaseDifference */ public String getReleaseDifferenceSummary() { ReleaseDifferenceSummaryGenerator releaseDifferenceSummaryGenerator = new ReleaseDifferenceSummaryGenerator(); return releaseDifferenceSummaryGenerator.generateSummary(existingRelease.getName(), existingRelease.getVersion(), replacingRelease.getName(), replacingRelease.getVersion(), this.releaseDifference); }
protected Release createInitialRelease(InstallProperties installProperties, Package packageToInstall, int releaseVersion) { Release release = new Release(); release.setName(installProperties.getReleaseName()); release.setPlatformName(installProperties.getPlatformName()); release.setConfigValues(installProperties.getConfigValues()); release.setPkg(packageToInstall); release.setVersion(releaseVersion); Info info = createNewInfo(); release.setInfo(info); validateInitialRelease(release); return release; }
public Release delete(Release release) { AppDeployer appDeployer = this.deployerRepository.findByNameRequired(release.getPlatformName()) .getAppDeployer(); AppDeployerData appDeployerData = this.appDeployerDataRepository .findByReleaseNameAndReleaseVersionRequired(release.getName(), release.getVersion()); List<String> deploymentIds = appDeployerData.getDeploymentIds(); if (!deploymentIds.isEmpty()) { for (String deploymentId : deploymentIds) { try { appDeployer.undeploy(deploymentId); } catch (Exception e) { this.logger.error(String.format("Exception undeploying the application with the deploymentId %s. " + "Exception message: %s", deploymentId, e.getMessage())); } } Status deletedStatus = new Status(); deletedStatus.setStatusCode(StatusCode.DELETED); release.getInfo().setStatus(deletedStatus); release.getInfo().setDescription("Delete complete"); this.releaseRepository.save(release); } return release; }
@Override public ReleaseAnalysisReport createReport(Release existingRelease, Release replacingRelease, boolean initial, boolean isForceUpdate, List<String> appNamesToUpgrade) { ReleaseAnalysisReport releaseAnalysisReport = this.releaseAnalyzer .analyze(existingRelease, replacingRelease, isForceUpdate, appNamesToUpgrade); List<String> applicationNamesToUpgrade = releaseAnalysisReport.getApplicationNamesToUpgrade(); if (releaseAnalysisReport.getReleaseDifference().areEqual() && !isForceUpdate) { throw new SkipperException( "Package to upgrade has no difference than existing deployed/deleted package. Not upgrading."); } AppDeployerData existingAppDeployerData = this.appDeployerDataRepository .findByReleaseNameAndReleaseVersionRequired( existingRelease.getName(), existingRelease.getVersion()); Map<String, String> existingAppNamesAndDeploymentIds = existingAppDeployerData.getDeploymentDataAsMap(); List<AppStatus> appStatuses = status(existingRelease).getInfo().getStatus().getAppStatusList(); Map<String, Object> model = calculateAppCountsForRelease(replacingRelease, existingAppNamesAndDeploymentIds, applicationNamesToUpgrade, appStatuses); String manifestData = ManifestUtils.createManifest(replacingRelease.getPkg(), model); Manifest manifest = new Manifest(); manifest.setData(manifestData); replacingRelease.setManifest(manifest); if (initial) { this.releaseRepository.save(replacingRelease); } return releaseAnalysisReport; }
tempReplacingRelease = createReleaseForUpgrade(packageMetadata, latestRelease.getVersion() + 1, upgradeProperties, existingRelease.getPlatformName(), rollbackRequest); upgradeRequest.getUpgradeProperties().getReleaseName(), latestRelease.getVersion()); Map<String, Object> mergedReplacingReleaseModel = ConfigValueUtils.mergeConfigValues(replacingRelease.getPkg(), replacingRelease.getConfigValues()); String manifestData = ManifestUtils.createManifest(replacingRelease.getPkg(), mergedReplacingReleaseModel); Manifest manifest = new Manifest(); manifest.setData(manifestData); replacingRelease.setManifest(manifest); String kind = ManifestUtils.resolveKind(existingRelease.getManifest().getData()); ReleaseManager releaseManager = this.releaseManagerFactory.getReleaseManager(kind); return releaseManager.createReport(existingRelease, replacingRelease, initial, upgradeRequest.isForce(),
String packageName = releaseToDelete.getPkg().getMetadata().getName(); if (this.packageMetadataService.filterReleasesFromLocalRepos( Arrays.asList(releaseToDelete), packageName).isEmpty()) { r -> (r.getName().equals(releaseToDelete.getName()) && r.getVersion() == releaseToDelete.getVersion()) ? false : PackageMetadataService.DEFAULT_RELEASE_ACTIVITY_CHECK.test(r)); String kind = ManifestUtils.resolveKind(releaseToDelete.getManifest().getData()); ReleaseManager releaseManager = this.releaseManagerFactory.getReleaseManager(kind); return releaseManager.delete(releaseToDelete);
StatusCode statusCode = releaseToRollback.getInfo().getStatus().getStatusCode(); if (!(statusCode.equals(StatusCode.DEPLOYED) || statusCode.equals(StatusCode.DELETED))) { throw new SkipperException("Rollback version should either be in deployed or deleted status."); currentRelease.getVersion(), rollbackVersionToUse); packageIdentifier.setPackageName(releaseToRollback.getPkg().getMetadata().getName()); packageIdentifier.setPackageVersion(releaseToRollback.getPkg().getMetadata().getVersion()); packageIdentifier.setRepositoryName(releaseToRollback.getPkg().getMetadata().getRepositoryName()); if (currentRelease.getInfo().getStatus().getStatusCode().equals(StatusCode.DELETED)) { InstallRequest installRequest = new InstallRequest(); InstallProperties installProperties = new InstallProperties(); installProperties.setConfigValues(releaseToRollback.getConfigValues()); installProperties.setPlatformName(releaseToRollback.getPlatformName()); installProperties.setReleaseName(releaseName); installRequest.setInstallProperties(installProperties); UpgradeProperties upgradeProperties = new UpgradeProperties(); upgradeProperties.setReleaseName(releaseName); upgradeProperties.setConfigValues(releaseToRollback.getConfigValues()); upgradeRequest.setUpgradeProperties(upgradeProperties); upgradeRequest.setPackageIdentifier(packageIdentifier);
/** * Return the manifest, the final set of instructions to deploy for a given release, given * the name and version. * @param releaseName the name of the release * @param version the release version * @return the release manifest */ @Transactional public Manifest manifest(String releaseName, Integer version) { return this.releaseRepository.findByNameAndVersion(releaseName, version).getManifest(); }
private void updateStatus(StringBuilder sb, Release release) { sb.append("Release Status: " + release.getInfo().getStatus().getStatusCode() + "\n"); if (StringUtils.hasText(release.getInfo().getStatus().getPlatformStatus())) { sb.append("Platform Status: " + release.getInfo().getStatus().getPlatformStatusPrettyPrint()); } else { sb.append("Platform Status: unknown"); } }
public Release delete(Release release, AppDeployerData existingAppDeployerData, List<String> applicationNamesToDelete) { AppDeployer appDeployer = this.deployerRepository.findByNameRequired(release.getPlatformName()) .getAppDeployer(); Map<String, String> appNamesAndDeploymentIds = existingAppDeployerData.getDeploymentDataAsMap(); for (Map.Entry<String, String> appNameAndDeploymentId : appNamesAndDeploymentIds.entrySet()) { if (applicationNamesToDelete.contains(appNameAndDeploymentId.getKey())) { AppStatus appStatus = appDeployer.status(appNameAndDeploymentId.getValue()); if (appStatus.getState().equals(DeploymentState.deployed)) { appDeployer.undeploy(appNameAndDeploymentId.getValue()); } else { logger.warn("For Release name {}, did not undeploy existing app {} as its status is not " + "'deployed'.", release.getName(), appNameAndDeploymentId.getKey()); } } } Status deletedStatus = new Status(); deletedStatus.setStatusCode(StatusCode.DELETED); release.getInfo().setStatus(deletedStatus); release.getInfo().setDescription("Delete complete"); this.releaseRepository.save(release); return release; } }
@Override public Release findReleaseToRollback(String releaseName) { Release latestRelease = this.releaseRepository.findLatestReleaseForUpdate(releaseName); List<Release> releases = this.releaseRepository.findByNameOrderByVersionDesc(releaseName); for (Release release : releases) { if ((release.getInfo().getStatus().getStatusCode().equals(StatusCode.DEPLOYED) || release.getInfo().getStatus().getStatusCode().equals(StatusCode.DELETED)) && release.getVersion() != latestRelease.getVersion()) { return release; } } throw new ReleaseNotFoundException(releaseName); }
public Release install(Release release) { Map<String, Object> mergedMap = ConfigValueUtils.mergeConfigValues(release.getPkg(), release.getConfigValues()); // Render yaml resources String manifestData = ManifestUtils.createManifest(release.getPkg(), mergedMap); logger.debug("Manifest = " + ArgumentSanitizer.sanitizeYml(manifestData)); Manifest manifest = new Manifest(); manifest.setData(manifestData); release.setManifest(manifest); // Deployment String kind = ManifestUtils.resolveKind(release.getManifest().getData()); ReleaseManager releaseManager = this.releaseManagerFactory.getReleaseManager(kind); Release releaseToReturn = releaseManager.install(release); return releaseToReturn; }
public List<String> getAllApplicationNames(Release release) { List<String> appNames = new ArrayList<>(); List<? extends SpringCloudDeployerApplicationManifest> applicationSpecList = this.applicationManifestReader .read(release.getManifest().getData()); if (release.getPkg().getDependencies().size() == 0) { appNames.add(applicationSpecList.get(0).getApplicationName()); } else { for (SpringCloudDeployerApplicationManifest applicationManifestSpec : applicationSpecList) { appNames.add(applicationManifestSpec.getApplicationName()); } } return appNames; }
public Release delete(Release release, AppDeployerData existingAppDeployerData, List<String> applicationNamesToDelete) { ApplicationManifest applicationManifest = CloudFoundryApplicationManifestUtils.updateApplicationName(release); String applicationName = applicationManifest.getName(); DeleteApplicationRequest deleteApplicationRequest = DeleteApplicationRequest.builder().name(applicationName) .build(); this.platformCloudFoundryOperations.getCloudFoundryOperations(release.getPlatformName()).applications() .delete(deleteApplicationRequest) .doOnSuccess(v -> logger.info("Successfully undeployed app {}", applicationName)) .doOnError(e -> logger.error("Failed to undeploy app %s", applicationName)).block(); Status deletedStatus = new Status(); deletedStatus.setStatusCode(StatusCode.DELETED); release.getInfo().setStatus(deletedStatus); release.getInfo().setDescription("Delete complete"); this.releaseRepository.save(release); return release; } }
public AppStatus status(Release release) { logger.info("Checking application status for the release: " + release.getName()); ApplicationManifest applicationManifest = CloudFoundryApplicationManifestUtils.updateApplicationName(release); String applicationName = applicationManifest.getName(); AppStatus appStatus = null; try { appStatus = getStatus(applicationName, release.getPlatformName()) .doOnSuccess(v -> logger.info("Successfully computed status [{}] for {}", v, applicationName)) .doOnError(e -> logger.error( String.format("Failed to compute status for %s", applicationName))) .block(); } catch (Exception timeoutDueToBlock) { logger.error("Caught exception while querying for status of {}", applicationName, timeoutDueToBlock); appStatus = createErrorAppStatus(applicationName); } return appStatus; }
ApplicationManifest applicationManifest = this.cfManifestApplicationDeployer.getCFApplicationManifest(release); Assert.isTrue(applicationManifest != null, "CF Application Manifest must be set"); logger.debug("Manifest = " + ArgumentSanitizer.sanitizeYml(newRelease.getManifest().getData())); this.platformCloudFoundryOperations.getCloudFoundryOperations(newRelease.getPlatformName()) .applications().pushManifest( PushApplicationManifestRequest.builder()
@Override public List<Release> findReleaseRevisions(String releaseName, Integer revisions) { int latestVersion = findLatestRelease(releaseName).getVersion(); int lowerVersion = latestVersion - Integer.valueOf(revisions); return this.releaseRepository.findByNameAndVersionBetweenOrderByNameAscVersionDesc(releaseName, lowerVersion + 1, latestVersion); }