diff --git a/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudBomConstants.java b/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudBomConstants.java new file mode 100644 index 00000000..c6039a42 --- /dev/null +++ b/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudBomConstants.java @@ -0,0 +1,46 @@ +/* + * Copyright 2013-2019 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.cloud.buildsystem; + +/** + * @author Marcin Grzejszczak + */ +final class SpringCloudBomConstants { + + // boot + static final String SPRING_BOOT = "spring-boot"; + static final String BOOT_STARTER_ARTIFACT_ID = "spring-boot-starter"; + static final String BOOT_STARTER_PARENT_ARTIFACT_ID = BOOT_STARTER_ARTIFACT_ID + + "-parent"; + static final String BOOT_DEPENDENCIES_ARTIFACT_ID = "spring-boot-dependencies"; + + // sc-build + static final String CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID = "spring-cloud-dependencies-parent"; + static final String BUILD_ARTIFACT_ID = "spring-cloud-build"; + + // sc-release + static final String CLOUD_DEPENDENCIES_ARTIFACT_ID = "spring-cloud-dependencies"; + static final String CLOUD_ARTIFACT_ID = "spring-cloud"; + static final String CLOUD_RELEASE_ARTIFACT_ID = "spring-cloud-release"; + static final String CLOUD_STARTER_ARTIFACT_ID = "spring-cloud-starter"; + static final String CLOUD_STARTER_PARENT_ARTIFACT_ID = "spring-cloud-starter-parent"; + + private SpringCloudBomConstants() { + throw new IllegalStateException("Don't instantiate a utility class"); + } + +} diff --git a/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudBuildsystemConfiguration.java b/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudBuildsystemConfiguration.java new file mode 100644 index 00000000..a2696d50 --- /dev/null +++ b/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudBuildsystemConfiguration.java @@ -0,0 +1,30 @@ +/* + * Copyright 2013-2019 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.cloud.buildsystem; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +@Configuration +class SpringCloudBuildsystemConfiguration { + + @Bean + SpringCloudMavenBomParser springCloudMavenBomParser() { + return new SpringCloudMavenBomParser(); + } + +} diff --git a/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudMavenBomParser.java b/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudMavenBomParser.java new file mode 100644 index 00000000..f5cedf64 --- /dev/null +++ b/projects/spring-cloud-stream/src/main/java/releaser/cloud/buildsystem/SpringCloudMavenBomParser.java @@ -0,0 +1,202 @@ +/* + * Copyright 2013-2019 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.cloud.buildsystem; + +import java.io.File; +import java.util.LinkedHashSet; +import java.util.Set; + +import org.apache.maven.model.Model; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import releaser.internal.ReleaserProperties; +import releaser.internal.buildsystem.CustomBomParser; +import releaser.internal.buildsystem.VersionsFromBom; +import releaser.internal.buildsystem.VersionsFromBomBuilder; +import releaser.internal.project.Project; +import releaser.internal.tech.PomReader; + +import org.springframework.util.StringUtils; + +import static releaser.cloud.buildsystem.SpringCloudBomConstants.BOOT_DEPENDENCIES_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.BOOT_STARTER_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.BUILD_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.CLOUD_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.CLOUD_DEPENDENCIES_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.CLOUD_RELEASE_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.CLOUD_STARTER_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.CLOUD_STARTER_PARENT_ARTIFACT_ID; +import static releaser.cloud.buildsystem.SpringCloudBomConstants.SPRING_BOOT; + +class SpringCloudMavenBomParser implements CustomBomParser { + + private static final Logger log = LoggerFactory + .getLogger(SpringCloudMavenBomParser.class); + + @Override + public VersionsFromBom parseBom(File root, ReleaserProperties properties) { + VersionsFromBom springCloudBuild = springCloudBuild(root, properties); + VersionsFromBom boot = bootVersion(root, properties); + log.debug("Added Spring Cloud Build [{}] and boot versions [{}]", + springCloudBuild, boot); + return new VersionsFromBomBuilder().thisProjectRoot(root) + .releaserProperties(properties).projects(springCloudBuild, boot).merged(); + } + + private VersionsFromBom springCloudBuild(File root, ReleaserProperties properties) { + String buildVersion = buildVersion(root, properties); + if (StringUtils.isEmpty(buildVersion)) { + return VersionsFromBom.EMPTY_VERSION; + } + VersionsFromBom scBuild = new VersionsFromBomBuilder().thisProjectRoot(root) + .releaserProperties(properties).merged(); + scBuild.add(BUILD_ARTIFACT_ID, buildVersion); + scBuild.add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildVersion); + return scBuild; + } + + private String buildVersion(File root, ReleaserProperties properties) { + String buildVersion = properties.getFixedVersions().get(BUILD_ARTIFACT_ID); + if (StringUtils.hasText(buildVersion)) { + return buildVersion; + } + File pom = new File(root, properties.getPom().getThisTrainBom()); + if (!pom.exists()) { + return ""; + } + Model model = PomReader.pom(root, properties.getPom().getThisTrainBom()); + String buildArtifact = model.getParent().getArtifactId(); + log.debug("[{}] artifact id is equal to [{}]", + CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildArtifact); + if (!CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID.equals(buildArtifact)) { + throw new IllegalStateException( + "The pom doesn't have a [spring-cloud-dependencies-parent] artifact id"); + } + buildVersion = model.getParent().getVersion(); + log.debug("Spring Cloud Build version is equal to [{}]", buildVersion); + return buildVersion; + } + + private String boot(File root, ReleaserProperties properties) { + String bootVersion = properties.getFixedVersions().get(SPRING_BOOT); + if (StringUtils.hasText(bootVersion)) { + return bootVersion; + } + String pomWithBootStarterParent = properties.getPom() + .getPomWithBootStarterParent(); + File pom = new File(root, pomWithBootStarterParent); + if (!pom.exists()) { + return ""; + } + Model model = PomReader.pom(root, pomWithBootStarterParent); + if (model == null) { + return ""; + } + String bootArtifactId = model.getParent().getArtifactId(); + log.debug("Boot artifact id is equal to [{}]", bootArtifactId); + if (!BOOT_STARTER_PARENT_ARTIFACT_ID.equals(bootArtifactId)) { + if (log.isDebugEnabled()) { + throw new IllegalStateException("The pom doesn't have a [" + + BOOT_STARTER_PARENT_ARTIFACT_ID + "] artifact id"); + } + return ""; + } + return model.getParent().getVersion(); + } + + VersionsFromBom bootVersion(File root, ReleaserProperties properties) { + String bootVersion = boot(root, properties); + if (StringUtils.isEmpty(bootVersion)) { + return VersionsFromBom.EMPTY_VERSION; + } + log.debug("Boot version is equal to [{}]", bootVersion); + VersionsFromBom versionsFromBom = new VersionsFromBomBuilder() + .thisProjectRoot(root).releaserProperties(properties).merged(); + versionsFromBom.add(SPRING_BOOT, bootVersion); + versionsFromBom.add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion); + versionsFromBom.add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion); + return versionsFromBom; + } + + @Override + public Set setVersion(Set projects, String projectName, + String version) { + Set newProjects = new LinkedHashSet<>(projects); + switch (projectName) { + case SPRING_BOOT: + case BOOT_STARTER_ARTIFACT_ID: + case BOOT_STARTER_PARENT_ARTIFACT_ID: + case BOOT_DEPENDENCIES_ARTIFACT_ID: + updateBootVersions(newProjects, version); + break; + case BUILD_ARTIFACT_ID: + case CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID: + updateBuildVersions(newProjects, version); + break; + case CLOUD_ARTIFACT_ID: + case CLOUD_DEPENDENCIES_ARTIFACT_ID: + case CLOUD_RELEASE_ARTIFACT_ID: + case CLOUD_STARTER_ARTIFACT_ID: + case CLOUD_STARTER_PARENT_ARTIFACT_ID: + updateSpringCloudVersions(newProjects, version); + break; + } + return newProjects; + } + + private void updateBootVersions(Set newProjects, String version) { + remove(newProjects, SPRING_BOOT); + remove(newProjects, BOOT_STARTER_ARTIFACT_ID); + remove(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID); + remove(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID); + add(newProjects, SPRING_BOOT, version); + add(newProjects, BOOT_STARTER_ARTIFACT_ID, version); + add(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID, version); + add(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID, version); + } + + private void updateBuildVersions(Set newProjects, String version) { + remove(newProjects, BUILD_ARTIFACT_ID); + remove(newProjects, CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID); + add(newProjects, BUILD_ARTIFACT_ID, version); + add(newProjects, CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, version); + } + + private void updateSpringCloudVersions(Set newProjects, String version) { + remove(newProjects, CLOUD_DEPENDENCIES_ARTIFACT_ID); + remove(newProjects, CLOUD_ARTIFACT_ID); + remove(newProjects, CLOUD_RELEASE_ARTIFACT_ID); + remove(newProjects, CLOUD_STARTER_ARTIFACT_ID); + remove(newProjects, CLOUD_STARTER_PARENT_ARTIFACT_ID); + add(newProjects, CLOUD_DEPENDENCIES_ARTIFACT_ID, version); + add(newProjects, CLOUD_ARTIFACT_ID, version); + add(newProjects, CLOUD_RELEASE_ARTIFACT_ID, version); + add(newProjects, CLOUD_STARTER_ARTIFACT_ID, version); + add(newProjects, CLOUD_STARTER_PARENT_ARTIFACT_ID, version); + } + + private void add(Set projects, String key, String value) { + projects.add(new Project(key, value)); + } + + private void remove(Set projects, String expectedProjectName) { + projects.removeIf(project -> expectedProjectName.equals(project.name)); + } + +}