From a3dff9d7b49d80b9cf392d15e91981a99fc3f193 Mon Sep 17 00:00:00 2001 From: Ryan Baxter <524254+ryanjbaxter@users.noreply.github.com> Date: Fri, 31 May 2024 16:41:13 -0400 Subject: [PATCH 1/4] Create tasks to create release bundles --- pom.xml | 14 ++- .../src/main/resources/application.yml | 55 ++++++++++ releaser-core/pom.xml | 8 ++ .../main/java/releaser/internal/Releaser.java | 46 +++++++- .../releaser/internal/ReleaserProperties.java | 74 +++++++++++++ .../commercial/ReleaseBundleCreator.java | 101 ++++++++++++++++++ .../java/releaser/internal/ReleaserTests.java | 18 +++- .../spring/ReleaserConfiguration.java | 11 +- .../spring/SpringBatchFlowRunner.java | 4 +- ...teProjectReleaseBundlePostReleaseTask.java | 74 +++++++++++++ ...easeTrainReleaseBundlePostReleaseTask.java | 73 +++++++++++++ .../PostReleaseTasksConfiguration.java | 14 +++ 12 files changed, 484 insertions(+), 8 deletions(-) create mode 100644 releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java create mode 100644 releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateProjectReleaseBundlePostReleaseTask.java create mode 100644 releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java diff --git a/pom.xml b/pom.xml index 1d4464d4..19d15d77 100644 --- a/pom.xml +++ b/pom.xml @@ -12,7 +12,7 @@ org.springframework.cloud spring-cloud-build - 4.0.3 + 4.0.6 @@ -47,6 +47,8 @@ 1.1.0 1.12 4.11.0 + 2.17.0 + 4.0.6 @@ -145,6 +147,16 @@ awaitility ${awaitility.version} + + org.jfrog.artifactory.client + artifactory-java-client-services + ${artifactory-client.version} + + + org.apache.groovy + groovy + ${groovy.version} + diff --git a/projects/spring-cloud/src/main/resources/application.yml b/projects/spring-cloud/src/main/resources/application.yml index c840cfdd..320d1de6 100644 --- a/projects/spring-cloud/src/main/resources/application.yml +++ b/projects/spring-cloud/src/main/resources/application.yml @@ -113,3 +113,58 @@ releaser: projects-to-skip: - spring-boot - spring-cloud-stream + bundles: + repos: + spring-cloud-build: + - "org/springframework/cloud/spring-cloud-build*" + - "org/springframework/cloud/spring-cloud-starter-build*" + - "org/springframework/cloud/spring-cloud-dependencies-parent*" + spring-cloud-config: + - "org/springframework/cloud/spring-cloud-config*" + - "org/springframework/cloud/spring-cloud-starter-config*" + spring-cloud-function: + - "org/springframework/cloud/spring-cloud-function*" + - "org/springframework/cloud/spring-cloud-starter-function*" + spring-cloud-stream: + - "org/springframework/cloud/spring-cloud-stream*" + - "org/springframework/cloud/spring-cloud-starter-stream*" + spring-cloud-task: + - "org/springframework/cloud/spring-cloud-task*" + - "org/springframework/cloud/spring-cloud-starter-task*" + spring-cloud-bus: + - "org/springframework/cloud/spring-cloud-bus*" + - "org/springframework/cloud/spring-cloud-starter-bus*" + spring-cloud-commons: + - "org/springframework/cloud/spring-cloud-commons*" + - "org/springframework/cloud/spring-cloud-starter-commons*" + spring-cloud-netflix: + - "org/springframework/cloud/spring-cloud-netflix*" + - "org/springframework/cloud/spring-cloud-starter-netflix*" + spring-cloud-openfeign: + - "org/springframework/cloud/spring-cloud-openfeign*" + - "org/springframework/cloud/spring-cloud-starter-openfeign*" + spring-cloud-consul: + - "org/springframework/cloud/spring-cloud-consul*" + - "org/springframework/cloud/spring-cloud-starter-consul*" + spring-cloud-circuitbreaker: + - "org/springframework/cloud/spring-cloud-circuitbreaker*" + - "org/springframework/cloud/spring-cloud-starter-circuitbreaker*" + spring-cloud-gateway: + - "org/springframework/cloud/spring-cloud-gateway*" + - "org/springframework/cloud/spring-cloud-starter-gateway*" + spring-cloud-zookeeper: + - "org/springframework/cloud/spring-cloud-zookeeper*" + - "org/springframework/cloud/spring-cloud-starter-zookeeper*" + spring-cloud-contract: + - "org/springframework/cloud/spring-cloud-contract*" + - "org/springframework/cloud/spring-cloud-starter-contract*" + spring-cloud-kubernetes: + - "org/springframework/cloud/spring-cloud-kubernetes*" + - "org/springframework/cloud/spring-cloud-starter-kubernetes*" + spring-cloud-vault: + - "org/springframework/cloud/spring-cloud-vault*" + - "org/springframework/cloud/spring-cloud-starter-vault*" + # This is Spring Cloud Release, the POM id is spring-cloud-starter-build + spring-cloud-starter-build: + - "org/springframework/cloud/spring-cloud-starter*" + - "org/springframework/cloud/spring-cloud-dependencies*" diff --git a/releaser-core/pom.xml b/releaser-core/pom.xml index 968d34e6..b0ee9beb 100644 --- a/releaser-core/pom.xml +++ b/releaser-core/pom.xml @@ -91,6 +91,14 @@ io.spring.initializr initializr-metadata + + org.jfrog.artifactory.client + artifactory-java-client-services + + + org.apache.groovy + groovy + org.springframework.boot spring-boot-starter-test diff --git a/releaser-core/src/main/java/releaser/internal/Releaser.java b/releaser-core/src/main/java/releaser/internal/Releaser.java index fe8ba8a7..4c1dae2c 100644 --- a/releaser-core/src/main/java/releaser/internal/Releaser.java +++ b/releaser-core/src/main/java/releaser/internal/Releaser.java @@ -18,11 +18,13 @@ package releaser.internal; import java.io.File; import java.util.List; +import java.util.Map; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import releaser.internal.buildsystem.GradleUpdater; import releaser.internal.buildsystem.ProjectPomUpdater; +import releaser.internal.commercial.ReleaseBundleCreator; import releaser.internal.docs.DocumentationUpdater; import releaser.internal.git.ProjectGitHandler; import releaser.internal.github.ProjectGitHubHandler; @@ -69,11 +71,13 @@ public class Releaser { private ReleaserProperties releaserProperties; + private ReleaseBundleCreator releaseBundleCreator; + public Releaser(ReleaserProperties releaserProperties, ProjectPomUpdater projectPomUpdater, ProjectCommandExecutor projectCommandExecutor, ProjectGitHandler projectGitHandler, ProjectGitHubHandler projectGitHubHandler, TemplateGenerator templateGenerator, GradleUpdater gradleUpdater, - SaganUpdater saganUpdater, DocumentationUpdater documentationUpdater, - PostReleaseActions postReleaseActions) { + SaganUpdater saganUpdater, DocumentationUpdater documentationUpdater, PostReleaseActions postReleaseActions, + ReleaseBundleCreator releaseBundleCreator) { this.releaserProperties = releaserProperties; this.projectPomUpdater = projectPomUpdater; this.projectCommandExecutor = projectCommandExecutor; @@ -84,6 +88,7 @@ public class Releaser { this.saganUpdater = saganUpdater; this.documentationUpdater = documentationUpdater; this.postReleaseActions = postReleaseActions; + this.releaseBundleCreator = releaseBundleCreator; } public File clonedProjectFromOrg(String projectName) { @@ -377,4 +382,41 @@ public class Releaser { return ExecutionResult.skipped(); } + public ExecutionResult createReleaseBundle(boolean commercial, ProjectVersion versionFromBom, Boolean dryRun, + Map> commercialRepos, String projectName) { + if (dryRun) { + log.info("\nWon't create a release bundle for a dry run"); + return ExecutionResult.skipped(); + } + if (versionFromBom.isSnapshot()) { + log.info("\nWon't create a release bundle for a SNAPSHOT version"); + return ExecutionResult.skipped(); + } + if (!commercial) { + log.info("\nWon't create a release bundle for a non commercial project"); + return ExecutionResult.skipped(); + } + log.info("\nCreating a release bundle"); + if (!commercialRepos.containsKey(projectName)) { + log.warn("No commercial repos configured for project [{}], double check releaser.bundles.repos", + projectName); + } + List repos = commercialRepos.get(projectName); + log.info("Creating release bundles for project [{}] in repos [{}]", projectName, repos); + try { + boolean result = this.releaseBundleCreator.createReleaseBundle(repos, versionFromBom.version, + "TNZ-" + projectName + "-commercial"); + if (!result) { + log.warn("Failed to create release bundle"); + return ExecutionResult.unstable(new BuildUnstableException("Failed to create a release bundle")); + } + log.info("\nSuccessfully created a release bundle"); + return ExecutionResult.success(); + } + catch (Exception ex) { + log.error("Failed to create a release bundle", ex); + return ExecutionResult.unstable(new BuildUnstableException("Failed to create a release bundle", ex)); + } + } + } diff --git a/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java b/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java index 5176229f..d6484235 100644 --- a/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java +++ b/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java @@ -80,6 +80,8 @@ public class ReleaserProperties implements Serializable { private boolean commercial = false; + private Bundles bundles = new Bundles(); + /** * Project name to its version - overrides all versions retrieved from a release train * repository like Spring Cloud Release. @@ -208,6 +210,14 @@ public class ReleaserProperties implements Serializable { this.commercial = commercial; } + public Bundles getBundles() { + return bundles; + } + + public void setBundles(Bundles bundles) { + this.bundles = bundles; + } + @Override public String toString() { return "ReleaserProperties{" + "workingDir='" + this.workingDir + '\'' + ", git=" + this.git + ", pom=" @@ -1563,4 +1573,68 @@ public class ReleaserProperties implements Serializable { } + public static class Bundles implements Serializable { + + private boolean createProjectReleaseBundle = false; + + private boolean createReleaseTrainReleaseBundle = false; + + private String repoUrl = "https://usw1.packages.broadcom.com"; + + private String repoUsername; + + private String repoAccessToken; + + private Map> repos; + + public boolean isCreateProjectReleaseBundle() { + return createProjectReleaseBundle; + } + + public void setCreateProjectReleaseBundle(boolean createProjectReleaseBundle) { + this.createProjectReleaseBundle = createProjectReleaseBundle; + } + + public boolean isCreateReleaseTrainReleaseBundle() { + return createReleaseTrainReleaseBundle; + } + + public void setCreateReleaseTrainReleaseBundle(boolean createReleaseTrainReleaseBundle) { + this.createReleaseTrainReleaseBundle = createReleaseTrainReleaseBundle; + } + + public Map> getRepos() { + return repos; + } + + public void setRepos(Map> repos) { + this.repos = repos; + } + + public String getRepoUrl() { + return repoUrl; + } + + public void setRepoUrl(String repoUrl) { + this.repoUrl = repoUrl; + } + + public String getRepoUsername() { + return repoUsername; + } + + public void setRepoUsername(String repoUsername) { + this.repoUsername = repoUsername; + } + + public String getRepoAccessToken() { + return repoAccessToken; + } + + public void setRepoAccessToken(String repoAccessToken) { + this.repoAccessToken = repoAccessToken; + } + + } + } diff --git a/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java b/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java new file mode 100644 index 00000000..66bc96d6 --- /dev/null +++ b/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java @@ -0,0 +1,101 @@ +/* + * Copyright 2013-2024 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package releaser.internal.commercial; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.jfrog.artifactory.client.Artifactory; +import org.jfrog.artifactory.client.ArtifactoryClientBuilder; +import org.jfrog.artifactory.client.ArtifactoryRequest; +import org.jfrog.artifactory.client.ArtifactoryResponse; +import org.jfrog.artifactory.client.aql.AqlItem; +import org.jfrog.artifactory.client.aql.AqlQueryBuilder; +import org.jfrog.artifactory.client.impl.ArtifactoryRequestImpl; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import releaser.internal.ReleaserProperties; + +/** + * @author Ryan Baxter + */ +public class ReleaseBundleCreator { + + private static final Logger log = LoggerFactory.getLogger(ReleaseBundleCreator.class); + + private Artifactory artifactory; + + private ObjectMapper objectMapper; + + public ReleaseBundleCreator(ReleaserProperties properties) { + log.info("Creating Artifactory client with URL [{}]", properties.getBundles().getRepoUrl()); + log.info("Creating Artifactory client with username [{}]", properties.getBundles().getRepoUsername()); + log.info("Creating Artifactory client with access token [{}]", properties.getBundles().getRepoAccessToken()); + this.artifactory = ArtifactoryClientBuilder.create().setUrl(properties.getBundles().getRepoUrl()) + .setUsername(properties.getBundles().getRepoUsername()) + .setAccessToken(properties.getBundles().getRepoAccessToken()).build(); + this.objectMapper = new ObjectMapper(); + } + + public boolean createReleaseBundle(List repos, String version, String releaseBundleName) throws IOException { + Map json = new HashMap<>(); + json.put("release_bundle_name", releaseBundleName); + json.put("release_bundle_version", version); + json.put( "source_type", "aql"); + json.put("source", createAqlMap(repos, version)); + return createReleaseBundle(objectMapper.writeValueAsString(json)); + } + + private Map createAqlMap(List repos, String version) { + String aql = createAql(repos, version); + Map aqlObject = new HashMap<>(); + aqlObject.put("aql", aql); + return aqlObject; + } + + private String createAql(List repos, String version) { + AqlQueryBuilder builder = new AqlQueryBuilder() + .item(AqlItem.aqlItem("repo", AqlItem.aqlItem("$eq", "spring-enterprise-maven-prod-local"))); + + AqlItem[] items = new AqlItem[repos.size()]; + for (String repo : repos) { + items[repos.indexOf(repo)] = AqlItem.match("path", repo + "/" + version); + } + return builder.or(items).asc("path", "name").build(); + } + + public boolean createReleaseBundle(String json) throws IOException { + log.info("Creating release bundle with JSON [{}]", json); + + ArtifactoryRequest aqlRequest = new ArtifactoryRequestImpl().method(ArtifactoryRequest.Method.POST) + .apiUrl("lifecycle/api/v2/release_bundle").addQueryParam("project", "spring") + .addHeader("X-JFrog-Signing-Key-Name", "packagesKey").requestType(ArtifactoryRequest.ContentType.JSON) + .responseType(ArtifactoryRequest.ContentType.JSON).requestBody(json); + ArtifactoryResponse response = artifactory.restCall(aqlRequest); + if (!response.isSuccessResponse()) { + log.warn("Failed to create release bundle {}", response.getRawBody()); + return false; + } + log.info("Created release bundle {}", response.getRawBody()); + return true; + + } + +} diff --git a/releaser-core/src/test/java/releaser/internal/ReleaserTests.java b/releaser-core/src/test/java/releaser/internal/ReleaserTests.java index 513bc71b..432e22db 100644 --- a/releaser-core/src/test/java/releaser/internal/ReleaserTests.java +++ b/releaser-core/src/test/java/releaser/internal/ReleaserTests.java @@ -17,6 +17,7 @@ package releaser.internal; import java.io.File; +import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import java.util.function.Supplier; @@ -31,6 +32,7 @@ import org.mockito.junit.jupiter.MockitoExtension; import releaser.SpringCloudReleaserProperties; import releaser.internal.buildsystem.GradleUpdater; import releaser.internal.buildsystem.ProjectPomUpdater; +import releaser.internal.commercial.ReleaseBundleCreator; import releaser.internal.docs.DocumentationUpdater; import releaser.internal.git.ProjectGitHandler; import releaser.internal.github.ProjectGitHubHandler; @@ -92,7 +94,13 @@ public class ReleaserTests { Releaser releaser(Supplier originalVersionSupplier) { return new Releaser(SpringCloudReleaserProperties.get(), this.projectPomUpdater, this.projectCommandExecutor, this.projectGitHandler, this.projectGitHubHandler, this.templateGenerator, this.gradleUpdater, - this.saganUpdater, this.documentationUpdater, this.postReleaseActions) { + this.saganUpdater, this.documentationUpdater, this.postReleaseActions, + new ReleaseBundleCreator(SpringCloudReleaserProperties.get()) { + @Override + public boolean createReleaseBundle(String json) throws IOException { + return true; + } + }) { @Override ProjectVersion originalVersion(File project) { return originalVersionSupplier.get(); @@ -103,7 +111,13 @@ public class ReleaserTests { Releaser releaser() { return new Releaser(new ReleaserProperties(), this.projectPomUpdater, this.projectCommandExecutor, this.projectGitHandler, this.projectGitHubHandler, this.templateGenerator, this.gradleUpdater, - this.saganUpdater, this.documentationUpdater, this.postReleaseActions); + this.saganUpdater, this.documentationUpdater, this.postReleaseActions, + new ReleaseBundleCreator(SpringCloudReleaserProperties.get()) { + @Override + public boolean createReleaseBundle(String json) throws IOException { + return true; + } + }); } @Test diff --git a/releaser-spring/src/main/java/releaser/internal/spring/ReleaserConfiguration.java b/releaser-spring/src/main/java/releaser/internal/spring/ReleaserConfiguration.java index dd1b20a9..9768a34b 100644 --- a/releaser-spring/src/main/java/releaser/internal/spring/ReleaserConfiguration.java +++ b/releaser-spring/src/main/java/releaser/internal/spring/ReleaserConfiguration.java @@ -24,6 +24,7 @@ import releaser.internal.ReleaserProperties; import releaser.internal.ReleaserPropertiesUpdater; import releaser.internal.buildsystem.GradleUpdater; import releaser.internal.buildsystem.ProjectPomUpdater; +import releaser.internal.commercial.ReleaseBundleCreator; import releaser.internal.docs.CustomProjectDocumentationUpdater; import releaser.internal.docs.DocumentationUpdater; import releaser.internal.git.ProjectGitHandler; @@ -154,10 +155,10 @@ class ReleaserConfiguration { ProjectGitHandler projectGitHandler, ProjectGitHubHandler projectGitHubHandler, TemplateGenerator templateGenerator, GradleUpdater gradleUpdater, SaganUpdater saganUpdater, DocumentationUpdater documentationUpdater, PostReleaseActions postReleaseActions, - ReleaserProperties releaserProperties) { + ReleaserProperties releaserProperties, ReleaseBundleCreator releaseBundleCreator) { return new Releaser(releaserProperties, projectPomUpdater, projectCommandExecutor, projectGitHandler, projectGitHubHandler, templateGenerator, gradleUpdater, saganUpdater, documentationUpdater, - postReleaseActions); + postReleaseActions, releaseBundleCreator); } @Bean @@ -173,4 +174,10 @@ class ReleaserConfiguration { return new OptionsParser(allTasks, singleProjectReleaserTasks, context); } + @Bean + @ConditionalOnMissingBean + ReleaseBundleCreator releaseBundleCreator(ReleaserProperties properties) { + return new ReleaseBundleCreator(properties); + } + } diff --git a/releaser-spring/src/main/java/releaser/internal/spring/SpringBatchFlowRunner.java b/releaser-spring/src/main/java/releaser/internal/spring/SpringBatchFlowRunner.java index 1341beff..f4a92835 100644 --- a/releaser-spring/src/main/java/releaser/internal/spring/SpringBatchFlowRunner.java +++ b/releaser-spring/src/main/java/releaser/internal/spring/SpringBatchFlowRunner.java @@ -211,7 +211,9 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable { @Override public ExecutionResult runReleaseTasks(Options options, ReleaserProperties properties, ProjectsToRun projectsToRun, TasksToRun tasksToRun) { - if (properties.isPostReleaseTasksOnly() && options.metaRelease) { + // TODO this seems to not be exclusive to meta releases + if (properties.isPostReleaseTasksOnly()/** && options.metaRelease */ + ) { log.info("Only post release tasks will be executed for the meta release"); return ExecutionResult.skipped(); } diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateProjectReleaseBundlePostReleaseTask.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateProjectReleaseBundlePostReleaseTask.java new file mode 100644 index 00000000..53a7ccfc --- /dev/null +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateProjectReleaseBundlePostReleaseTask.java @@ -0,0 +1,74 @@ +/* + * Copyright 2013-2024 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package releaser.internal.tasks.postrelease; + +import releaser.internal.Releaser; +import releaser.internal.project.ProjectVersion; +import releaser.internal.spring.Arguments; +import releaser.internal.tasks.ProjectPostReleaseReleaserTask; +import releaser.internal.tech.BuildUnstableException; +import releaser.internal.tech.ExecutionResult; + +/** + * @author Ryan Baxter + */ +public class CreateProjectReleaseBundlePostReleaseTask implements ProjectPostReleaseReleaserTask { + + /** + * Order of this task. The higher value, the lower order. + */ + public static final int ORDER = 60; + + private final Releaser releaser; + + public CreateProjectReleaseBundlePostReleaseTask(Releaser releaser) { + this.releaser = releaser; + } + + @Override + public String name() { + return "createReleaseBundle"; + } + + @Override + public String shortName() { + return "b"; + } + + @Override + public String header() { + return "CREATING RELEASE BUNDLE"; + } + + @Override + public String description() { + return "Creates a release bundle for the project"; + } + + @Override + public ExecutionResult runTask(Arguments args) throws BuildUnstableException, RuntimeException { + return this.releaser.createReleaseBundle(args.properties.isCommercial(), args.versionFromBom, + args.options.dryRun, args.properties.getBundles().getRepos(), + new ProjectVersion(args.project).projectName); + } + + @Override + public int getOrder() { + return ORDER; + } + +} diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java new file mode 100644 index 00000000..779c9c49 --- /dev/null +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java @@ -0,0 +1,73 @@ +/* + * Copyright 2013-2024 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package releaser.internal.tasks.postrelease; + +import releaser.internal.Releaser; +import releaser.internal.project.ProjectVersion; +import releaser.internal.spring.Arguments; +import releaser.internal.tasks.TrainPostReleaseReleaserTask; +import releaser.internal.tech.BuildUnstableException; +import releaser.internal.tech.ExecutionResult; + +/** + * @author Ryan Baxter + */ +public class CreateReleaseTrainReleaseBundlePostReleaseTask implements TrainPostReleaseReleaserTask { + + /** + * Order of this task. The higher value, the lower order. + */ + public static final int ORDER = 160; + + private final Releaser releaser; + + public CreateReleaseTrainReleaseBundlePostReleaseTask(Releaser releaser) { + this.releaser = releaser; + } + + @Override + public String name() { + return "createReleaseTrainReleaseBundlePostReleaseTask"; + } + + @Override + public String shortName() { + return "rtb"; + } + + @Override + public String header() { + return "CREATE RELEASE TRAIN RELEASE BUNDLE"; + } + + @Override + public String description() { + return "Creates a release train release bundle"; + } + + @Override + public ExecutionResult runTask(Arguments args) throws BuildUnstableException, RuntimeException { + return releaser.createReleaseBundle(args.properties.isCommercial(), args.versionFromBom, args.options.dryRun, + args.properties.getBundles().getRepos(), new ProjectVersion(args.project).projectName); + } + + @Override + public int getOrder() { + return ORDER; + } + +} diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java index ce824c13..f7acf615 100644 --- a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java @@ -92,4 +92,18 @@ class PostReleaseTasksConfiguration { return new UpdateStartSpringIoTrainPostReleaseTask(releaser); } + @Bean + @ConditionalOnMissingBean + @ConditionalOnProperty("releaser.bundles.create-release-train-release-bundle") + CreateReleaseTrainReleaseBundlePostReleaseTask createReleaseTrainReleaseBundlePostReleaseTask(Releaser releaser) { + return new CreateReleaseTrainReleaseBundlePostReleaseTask(releaser); + } + + @Bean + @ConditionalOnMissingBean + @ConditionalOnProperty("releaser.bundles.create-project-release-bundle") + CreateProjectReleaseBundlePostReleaseTask createProjectReleaseBundlePostReleaseTask(Releaser releaser) { + return new CreateProjectReleaseBundlePostReleaseTask(releaser); + } + } From f3140bafe66cf0256581f12bc8bbcc688fbd1186 Mon Sep 17 00:00:00 2001 From: Ryan Baxter <524254+ryanjbaxter@users.noreply.github.com> Date: Thu, 6 Jun 2024 10:25:30 -0400 Subject: [PATCH 2/4] Initial implementation to distribute release bundles --- .../main/java/releaser/internal/Releaser.java | 72 ++++++++++++--- .../releaser/internal/ReleaserProperties.java | 10 +++ .../commercial/ReleaseBundleCreator.java | 89 +++++++++++++++++-- ...easeTrainReleaseBundlePostReleaseTask.java | 16 +++- .../DistributeReleaseBundleTask.java | 72 +++++++++++++++ .../PostReleaseTasksConfiguration.java | 7 ++ 6 files changed, 244 insertions(+), 22 deletions(-) create mode 100644 releaser-spring/src/main/java/releaser/internal/tasks/postrelease/DistributeReleaseBundleTask.java diff --git a/releaser-core/src/main/java/releaser/internal/Releaser.java b/releaser-core/src/main/java/releaser/internal/Releaser.java index 4c1dae2c..c37e588a 100644 --- a/releaser-core/src/main/java/releaser/internal/Releaser.java +++ b/releaser-core/src/main/java/releaser/internal/Releaser.java @@ -384,16 +384,7 @@ public class Releaser { public ExecutionResult createReleaseBundle(boolean commercial, ProjectVersion versionFromBom, Boolean dryRun, Map> commercialRepos, String projectName) { - if (dryRun) { - log.info("\nWon't create a release bundle for a dry run"); - return ExecutionResult.skipped(); - } - if (versionFromBom.isSnapshot()) { - log.info("\nWon't create a release bundle for a SNAPSHOT version"); - return ExecutionResult.skipped(); - } - if (!commercial) { - log.info("\nWon't create a release bundle for a non commercial project"); + if (!shouldCreateReleaseBundle(dryRun, versionFromBom.isSnapshot(), commercial)) { return ExecutionResult.skipped(); } log.info("\nCreating a release bundle"); @@ -419,4 +410,65 @@ public class Releaser { } } + private boolean shouldCreateReleaseBundle(boolean dryRun, boolean isSnapshot, boolean commercial) { + if (!dryRun && !isSnapshot && commercial) { + return true; + } + if (dryRun) { + log.info("\nWon't create a release bundle for a dry run"); + } + if (isSnapshot) { + log.info("\nWon't create a release bundle for a SNAPSHOT version"); + } + if (!commercial) { + log.info("\nWon't create a release bundle for a non commercial project"); + } + return false; + } + + public ExecutionResult createReleaseTrainSourceBundle(List projectsWithNewRelease, + boolean isCommercial, boolean dryRun, ProjectVersion projectVersion) { + if (!shouldCreateReleaseBundle(dryRun, projectVersion.isSnapshot(), isCommercial)) { + return ExecutionResult.skipped(); + } + try { + boolean result = this.releaseBundleCreator.createReleaseTrainSourceBundle(projectsWithNewRelease, + projectVersion.version); + if (!result) { + log.warn("Failed to create release train source bundle"); + return ExecutionResult + .unstable(new BuildUnstableException("Failed to create a release train source bundle")); + } + log.info("\nSuccessfully created a release train source bundle"); + return ExecutionResult.success(); + } + catch (Exception ex) { + log.error("Failed to create a release train source bundle", ex); + return ExecutionResult + .unstable(new BuildUnstableException("Failed to create a release train source bundle", ex)); + } + } + + public ExecutionResult distributeReleaseTrainSourceBundle(boolean isCommercial, boolean dryRun, + ProjectVersion projectVersion) { + if (!shouldCreateReleaseBundle(dryRun, projectVersion.isSnapshot(), isCommercial)) { + return ExecutionResult.skipped(); + } + try { + boolean result = this.releaseBundleCreator.distributeReleaseTrainSourceBundle(projectVersion.version); + if (!result) { + log.warn("Failed to distribute release train source bundle"); + return ExecutionResult + .unstable(new BuildUnstableException("Failed to distribute a release train source bundle")); + } + log.info("\nSuccessfully distributed a release train source bundle"); + return ExecutionResult.success(); + } + catch (Exception ex) { + log.error("Failed to distribute a release train source bundle", ex); + return ExecutionResult + .unstable(new BuildUnstableException("Failed to distribute a release train source bundle", ex)); + } + } + } diff --git a/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java b/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java index d6484235..cd3181e9 100644 --- a/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java +++ b/releaser-core/src/main/java/releaser/internal/ReleaserProperties.java @@ -1579,6 +1579,8 @@ public class ReleaserProperties implements Serializable { private boolean createReleaseTrainReleaseBundle = false; + private boolean distributeReleaseBundle = false; + private String repoUrl = "https://usw1.packages.broadcom.com"; private String repoUsername; @@ -1603,6 +1605,14 @@ public class ReleaserProperties implements Serializable { this.createReleaseTrainReleaseBundle = createReleaseTrainReleaseBundle; } + public boolean isDistributeReleaseBundle() { + return distributeReleaseBundle; + } + + public void setDistributeReleaseBundle(boolean distributeReleaseBundle) { + this.distributeReleaseBundle = distributeReleaseBundle; + } + public Map> getRepos() { return repos; } diff --git a/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java b/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java index 66bc96d6..f9cb43e8 100644 --- a/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java +++ b/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java @@ -17,6 +17,9 @@ package releaser.internal.commercial; import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -32,6 +35,7 @@ import org.jfrog.artifactory.client.impl.ArtifactoryRequestImpl; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import releaser.internal.ReleaserProperties; +import releaser.internal.project.ProjectVersion; /** * @author Ryan Baxter @@ -40,9 +44,11 @@ public class ReleaseBundleCreator { private static final Logger log = LoggerFactory.getLogger(ReleaseBundleCreator.class); - private Artifactory artifactory; + public static final String RELEASE_TRAIN_BUNDLE_NAME = "TNZ-spring-cloud-commercial-release"; - private ObjectMapper objectMapper; + private final Artifactory artifactory; + + private final ObjectMapper objectMapper; public ReleaseBundleCreator(ReleaserProperties properties) { log.info("Creating Artifactory client with URL [{}]", properties.getBundles().getRepoUrl()); @@ -54,11 +60,12 @@ public class ReleaseBundleCreator { this.objectMapper = new ObjectMapper(); } - public boolean createReleaseBundle(List repos, String version, String releaseBundleName) throws IOException { + public boolean createReleaseBundle(List repos, String version, String releaseBundleName) + throws IOException { Map json = new HashMap<>(); json.put("release_bundle_name", releaseBundleName); json.put("release_bundle_version", version); - json.put( "source_type", "aql"); + json.put("source_type", "aql"); json.put("source", createAqlMap(repos, version)); return createReleaseBundle(objectMapper.writeValueAsString(json)); } @@ -88,13 +95,77 @@ public class ReleaseBundleCreator { .apiUrl("lifecycle/api/v2/release_bundle").addQueryParam("project", "spring") .addHeader("X-JFrog-Signing-Key-Name", "packagesKey").requestType(ArtifactoryRequest.ContentType.JSON) .responseType(ArtifactoryRequest.ContentType.JSON).requestBody(json); - ArtifactoryResponse response = artifactory.restCall(aqlRequest); + return makeArtifactoryRequest(aqlRequest); + } + + public boolean createReleaseTrainSourceBundle(List projectsReleased, String version) + throws IOException { + log.info("Creating release train source bundle for projects {}", projectsReleased); + Map json = new HashMap<>(); + json.put("release_bundle_name", RELEASE_TRAIN_BUNDLE_NAME); + json.put("release_bundle_version", version); + json.put("skip_docker_manifest_resolution", false); + json.put("source_type", "release_bundles"); + json.put("source", createReleaseBundlesJson(projectsReleased)); + return createReleaseBundle(objectMapper.writeValueAsString(json)); + } + + private Map createReleaseBundlesJson(List projectsReleased) { + Map json = new HashMap<>(); + List> releaseBundles = new ArrayList<>(); + projectsReleased.forEach(project -> releaseBundles.add(createReleaseBundleJson(project))); + json.put("release_bundles", releaseBundles); + return json; + } + + private Map createReleaseBundleJson(ProjectVersion project) { + Map json = new HashMap<>(); + json.put("project_key", "spring"); + json.put("repository_key", "spring-release-bundles-v2"); + json.put("release_bundle_name", "TNZ-" + project.projectName + "-commercial"); + json.put("release_bundle_version", project.version); + return json; + } + + public boolean distributeReleaseTrainSourceBundle(String version) throws IOException { + return distributeReleaseBundle(RELEASE_TRAIN_BUNDLE_NAME, version, + objectMapper.writeValueAsString(createDistributionJson())); + } + + public boolean distributeReleaseBundle(String releaseBundleName, String version, String json) throws IOException { + log.info("Distributing release bundle with name [{}] and version[{}] and JSON data [{}]", releaseBundleName, + version, json); + ArtifactoryRequest request = new ArtifactoryRequestImpl().method(ArtifactoryRequest.Method.POST) + .apiUrl("lifecycle/api/v2/distribution/distribute/" + RELEASE_TRAIN_BUNDLE_NAME + "/" + version) + .addQueryParam("project", "spring").requestType(ArtifactoryRequest.ContentType.JSON) + .responseType(ArtifactoryRequest.ContentType.JSON).requestBody(json); + return makeArtifactoryRequest(request); + } + + private boolean makeArtifactoryRequest(ArtifactoryRequest request) throws IOException { + ArtifactoryResponse response = artifactory.restCall(request); if (!response.isSuccessResponse()) { - log.warn("Failed to create release bundle {}", response.getRawBody()); - return false; + log.warn("Artifactory request failed {}", response.getRawBody()); } - log.info("Created release bundle {}", response.getRawBody()); - return true; + else { + log.info("Artifactory request succeeded {}", response.getRawBody()); + } + return response.isSuccessResponse(); + } + + private Map createDistributionJson() { + Map json = new HashMap<>(); + json.put("auto_create_missing_repositories", "false"); + json.put("distribution_rules", List.of(Collections.singletonMap("site_name", "JP-SaaS"))); + json.put("modifications", createMappings()); + return json; + } + + private Map createMappings() { + Map input = Collections.singletonMap("input", "spring-enterprise-maven-prod-local/(.*)"); + Map output = Collections.singletonMap("output", "spring-enterprise/$1"); + List> mappingsArray = Arrays.asList(input, output); + return Collections.singletonMap("mappings", mappingsArray); } diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java index 779c9c49..05748d5f 100644 --- a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateReleaseTrainReleaseBundlePostReleaseTask.java @@ -16,6 +16,9 @@ package releaser.internal.tasks.postrelease; +import java.util.LinkedList; +import java.util.List; + import releaser.internal.Releaser; import releaser.internal.project.ProjectVersion; import releaser.internal.spring.Arguments; @@ -60,9 +63,16 @@ public class CreateReleaseTrainReleaseBundlePostReleaseTask implements TrainPost } @Override - public ExecutionResult runTask(Arguments args) throws BuildUnstableException, RuntimeException { - return releaser.createReleaseBundle(args.properties.isCommercial(), args.versionFromBom, args.options.dryRun, - args.properties.getBundles().getRepos(), new ProjectVersion(args.project).projectName); + public ExecutionResult runTask(Arguments args) throws BuildUnstableException { + List releasedProjects = new LinkedList<>(); + args.projects.forEach(projectVersion -> { + if (args.properties.getMetaRelease().getProjectsToSkip().stream() + .noneMatch(projectVersion.projectName::startsWith)) { + releasedProjects.add(projectVersion); + } + }); + return releaser.createReleaseTrainSourceBundle(releasedProjects, args.properties.isCommercial(), + args.options.dryRun, args.versionFromBom); } @Override diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/DistributeReleaseBundleTask.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/DistributeReleaseBundleTask.java new file mode 100644 index 00000000..ed002883 --- /dev/null +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/DistributeReleaseBundleTask.java @@ -0,0 +1,72 @@ +/* + * Copyright 2013-2024 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package releaser.internal.tasks.postrelease; + +import releaser.internal.Releaser; +import releaser.internal.spring.Arguments; +import releaser.internal.tasks.TrainPostReleaseReleaserTask; +import releaser.internal.tech.BuildUnstableException; +import releaser.internal.tech.ExecutionResult; + +/** + * @author Ryan Baxter + */ +public class DistributeReleaseBundleTask implements TrainPostReleaseReleaserTask { + + /** + * Order of this task. The higher value, the lower order. + */ + public static final int ORDER = CreateReleaseTrainReleaseBundlePostReleaseTask.ORDER + 10; + + private final Releaser releaser; + + public DistributeReleaseBundleTask(Releaser releaser) { + this.releaser = releaser; + } + + @Override + public String name() { + return "distributeReleaseBundleTask"; + } + + @Override + public String shortName() { + return "drb"; + } + + @Override + public String header() { + return "DISTRIBUTING RELEASE BUNDLE"; + } + + @Override + public String description() { + return "Distributes the release bundle to the edge repository."; + } + + @Override + public ExecutionResult runTask(Arguments args) throws BuildUnstableException { + return releaser.distributeReleaseTrainSourceBundle(args.properties.isCommercial(), args.options.dryRun, + args.versionFromBom); + } + + @Override + public int getOrder() { + return ORDER; + } + +} diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java index f7acf615..72359fb8 100644 --- a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java @@ -106,4 +106,11 @@ class PostReleaseTasksConfiguration { return new CreateProjectReleaseBundlePostReleaseTask(releaser); } + @Bean + @ConditionalOnMissingBean + @ConditionalOnProperty("releaser.bundles.distribute-release-bundle") + DistributeReleaseBundleTask distributeReleaseBundleTask(Releaser releaser) { + return new DistributeReleaseBundleTask(releaser); + } + } From 8aa6a08283c316d45d0b74b8b88860f2785cea60 Mon Sep 17 00:00:00 2001 From: Ryan Baxter <524254+ryanjbaxter@users.noreply.github.com> Date: Thu, 6 Jun 2024 10:46:47 -0400 Subject: [PATCH 3/4] Formatting --- releaser-core/src/main/java/releaser/internal/Releaser.java | 1 + .../java/releaser/internal/commercial/ReleaseBundleCreator.java | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/releaser-core/src/main/java/releaser/internal/Releaser.java b/releaser-core/src/main/java/releaser/internal/Releaser.java index f66c01b2..c37e588a 100644 --- a/releaser-core/src/main/java/releaser/internal/Releaser.java +++ b/releaser-core/src/main/java/releaser/internal/Releaser.java @@ -470,4 +470,5 @@ public class Releaser { .unstable(new BuildUnstableException("Failed to distribute a release train source bundle", ex)); } } + } diff --git a/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java b/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java index e7856169..6db15e6e 100644 --- a/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java +++ b/releaser-core/src/main/java/releaser/internal/commercial/ReleaseBundleCreator.java @@ -50,7 +50,6 @@ public class ReleaseBundleCreator { private final ObjectMapper objectMapper; - public ReleaseBundleCreator(ReleaserProperties properties) { log.info("Creating Artifactory client with URL [{}]", properties.getBundles().getRepoUrl()); log.info("Creating Artifactory client with username [{}]", properties.getBundles().getRepoUsername()); From 0e738265adc7bce6d69c17495a6bbb62e364cec9 Mon Sep 17 00:00:00 2001 From: Ryan Baxter <524254+ryanjbaxter@users.noreply.github.com> Date: Thu, 6 Jun 2024 10:46:55 -0400 Subject: [PATCH 4/4] Formatting --- .../tasks/postrelease/PostReleaseTasksConfiguration.java | 1 + 1 file changed, 1 insertion(+) diff --git a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java index 345d6e88..72359fb8 100644 --- a/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java +++ b/releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java @@ -112,4 +112,5 @@ class PostReleaseTasksConfiguration { DistributeReleaseBundleTask distributeReleaseBundleTask(Releaser releaser) { return new DistributeReleaseBundleTask(releaser); } + }