SpringCloud/spring-cloud-release-tools
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Updates the Release Train table in Spring project

Browse Source 
fixes gh-93
This commit is contained in:
Marcin Grzejszczak
2018-10-18 15:27:12 +02:00
parent a9945f2df3
commit 9d8235e310
82 changed files with 3271 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/Releaser.java
View File

@@ -196,4 +196,16 @@ public class Releaser {
log.warn("\nUnable to update documentation repository for branch ["+ releaseBranch + "]", e);
}
}
public void updateSpringProjectPage(Projects projects) {
try {
if (this.documentationUpdater.updateProjectRepo(projects) != null) {
log.info("\nSuccessfully updated Spring project page");
} else {
log.warn("\nFailed to update Spring Project page");
}
} catch (Exception e) {
log.warn("\nUnable to update Spring Project page", e);
}
}
}

44
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/ReleaserProperties.java
View File

@@ -22,7 +22,6 @@ import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
import org.apache.commons.lang.SerializationUtils;
@@ -147,11 +146,21 @@ public class ReleaserProperties implements Serializable {
*/
private String documentationUrl = "https://github.com/spring-cloud/spring-cloud-static";
/**
* URL to main release train project repository
*/
private String springProjectUrl = "https://github.com/spring-projects/spring-cloud";
/**
* Branch to check out for the documentation project
*/
private String documentationBranch = "gh-pages";
/**
* Branch to check out for the release train project
*/
private String springProjectBranch = "gh-pages";
/**
* If {@code false}, will not update the documentation repository.
*/
@@ -193,6 +202,12 @@ public class ReleaserProperties implements Serializable {
*/
private boolean updateSpringGuides = true;
/**
* If set to {@code false}, will not update the Spring Project for a release train.
* E.g. for Spring Cloud will not update https://cloud.spring.io
*/
private boolean updateSpringProject = true;
public String getReleaseTrainBomUrl() {
return this.releaseTrainBomUrl;
}
@@ -209,6 +224,14 @@ public class ReleaserProperties implements Serializable {
this.documentationUrl = documentationUrl;
}
public String getSpringProjectUrl() {
return this.springProjectUrl;
}
public void setSpringProjectUrl(String springProjectUrl) {
this.springProjectUrl = springProjectUrl;
}
public String getDocumentationBranch() {
return this.documentationBranch;
}
@@ -217,6 +240,14 @@ public class ReleaserProperties implements Serializable {
this.documentationBranch = documentationBranch;
}
public String getSpringProjectBranch() {
return this.springProjectBranch;
}
public void setSpringProjectBranch(String springProjectBranch) {
this.springProjectBranch = springProjectBranch;
}
public boolean isUpdateDocumentationRepo() {
return this.updateDocumentationRepo;
}
@@ -281,6 +312,14 @@ public class ReleaserProperties implements Serializable {
this.updateSpringGuides = updateSpringGuides;
}
public boolean isUpdateSpringProject() {
return this.updateSpringProject;
}
public void setUpdateSpringProject(boolean updateSpringProject) {
this.updateSpringProject = updateSpringProject;
}
@Override
public String toString() {
return "Git{" +
@@ -288,11 +327,14 @@ public class ReleaserProperties implements Serializable {
", documentationUrl='" + this.documentationUrl + '\'' +
", documentationBranch='" + this.documentationBranch + '\'' +
", updateDocumentationRepo=" + this.updateDocumentationRepo +
", springProjectUrl=" + this.springProjectUrl+
", springProjectBranch=" + this.springProjectBranch +
", cloneDestinationDir='" + this.cloneDestinationDir + '\'' +
", fetchVersionsFromGit=" + this.fetchVersionsFromGit +
", oauthToken='" + this.oauthToken + '\'' +
", numberOfCheckedMilestones=" + this.numberOfCheckedMilestones +
", updateSpringGuides=" + this.updateSpringGuides +
", updateSpringProject=" + this.updateSpringProject +
'}';
}
}

107
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/DocumentationUpdater.java
View File

@@ -1,31 +1,33 @@
package org.springframework.cloud.release.internal.docs;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.ReleaserPropertiesAware;
import org.springframework.cloud.release.internal.git.ProjectGitHandler;
import org.springframework.cloud.release.internal.pom.ProjectVersion;
import org.springframework.cloud.release.internal.pom.Projects;
/**
* @author Marcin Grzejszczak
*/
public class DocumentationUpdater {
public class DocumentationUpdater implements ReleaserPropertiesAware {
private static final String SC_STATIC_URL = "http://cloud.spring.io/spring-cloud-static/";
private static final Logger log = LoggerFactory.getLogger(DocumentationUpdater.class);
private final ProjectDocumentationUpdater projectDocumentationUpdater;
private final ReleaseTrainContentsUpdater releaseTrainContentsUpdater;
private ReleaserProperties properties;
private final ProjectGitHandler gitHandler;
private final ReleaserProperties properties;
public DocumentationUpdater(ReleaserProperties properties,
ProjectGitHandler gitHandler) {
this.gitHandler = gitHandler;
public DocumentationUpdater(ProjectGitHandler gitHandler, ReleaserProperties properties) {
this.properties = properties;
this.projectDocumentationUpdater = new ProjectDocumentationUpdater(this.properties, gitHandler);
this.releaseTrainContentsUpdater = new ReleaseTrainContentsUpdater(this.properties, gitHandler);
}
DocumentationUpdater(ReleaserProperties properties, ProjectDocumentationUpdater updater,
ReleaseTrainContentsUpdater contentsUpdater) {
this.properties = properties;
this.projectDocumentationUpdater = updater;
this.releaseTrainContentsUpdater = contentsUpdater;
}
/**
@@ -37,70 +39,25 @@ public class DocumentationUpdater {
* @return {@link File cloned temporary directory} - {@code null} if wrong version is used
*/
public File updateDocsRepo(ProjectVersion currentProject, String springCloudReleaseBranch) {
if (!properties.getGit().isUpdateDocumentationRepo()) {
log.info("Will not update documentation repository, since the switch to do so "
+ "is off. Set [releaser.git.update-documentation-repo] to [true] to change that");
return null;
}
if (!currentProject.isReleaseOrServiceRelease()) {
log.info("Will not update documentation repository for non release or service release [{}]", currentProject.version);
return null;
}
File documentationProject = this.gitHandler.cloneDocumentationProject();
log.debug("Cloning the doc project to [{}]", documentationProject);
String pathToIndexHtml = "current/index.html";
File indexHtml = new File(documentationProject, pathToIndexHtml);
if (!indexHtml.exists()) {
throw new IllegalStateException("index.html is not present at [" + pathToIndexHtml + "]");
}
try {
String indexHtmlText = readIndexHtmlContents(indexHtml);
int index = indexHtmlText.indexOf(SC_STATIC_URL);
if (index == -1) {
throw new IllegalStateException("The URL to the documentation repo not found in the index.html file");
}
int beginIndex = index + SC_STATIC_URL.length();
String storedReleaseTrainLine = indexHtmlText.substring(beginIndex);
String storedReleaseTrain = storedReleaseTrainLine.substring(0, storedReleaseTrainLine.indexOf("/"));
String firstLetterOfReleaseTrain = String.valueOf(storedReleaseTrain.charAt(0));
String currentReleaseTrainVersion = branchToReleaseVersion(springCloudReleaseBranch);
String firstLetterOfCurrentReleaseTrain = String.valueOf(currentReleaseTrainVersion.charAt(0));
boolean newerOrEqualReleaseTrain = (!storedReleaseTrain.equals(currentReleaseTrainVersion)) && firstLetterOfCurrentReleaseTrain
.compareToIgnoreCase(firstLetterOfReleaseTrain) >= 0;
if (!newerOrEqualReleaseTrain) {
log.info("Current release train [{}] is not newer than the stored one [{}]",
currentReleaseTrainVersion, storedReleaseTrain);
return documentationProject;
}
return pushCommitedChanges(currentReleaseTrainVersion, documentationProject,
indexHtml, indexHtmlText, storedReleaseTrain);
}
catch (IOException e) {
throw new IllegalStateException(e);
}
return this.projectDocumentationUpdater
.updateDocsRepo(currentProject, springCloudReleaseBranch);
}
private String branchToReleaseVersion(String springCloudReleaseBranch) {
if (springCloudReleaseBranch.startsWith("v")) {
return springCloudReleaseBranch.substring(1);
}
return springCloudReleaseBranch;
/**
* Updates the project page if current release train version is greater or equal
* than the one stored in the repo.
*
* @param projects
* @return {@link File cloned temporary directory} - {@code null} if wrong version is used or the switch is turned off
*/
public File updateProjectRepo(Projects projects) {
return this.releaseTrainContentsUpdater.updateProjectRepo(projects);
}
private File pushCommitedChanges(String currentReleaseTrainVersion,
File documentationProject, File indexHtml, String indexHtmlText,
String storedReleaseTrain) throws IOException {
String replacedIndexHtml = indexHtmlText.replace(storedReleaseTrain, currentReleaseTrainVersion);
Files.write(indexHtml.toPath(), replacedIndexHtml.getBytes());
log.info("Stored the release train [{}] in [{}]",
currentReleaseTrainVersion, indexHtml.getAbsolutePath());
this.gitHandler.commit(documentationProject, "Updating the link to the current version to [" + currentReleaseTrainVersion + "]");
this.gitHandler.pushCurrentBranch(documentationProject);
log.info("Committed and pushed changes to the documentation project");
return documentationProject;
}
String readIndexHtmlContents(File indexHtml) throws IOException {
return new String(Files.readAllBytes(indexHtml.toPath()));
@Override
public void setReleaserProperties(ReleaserProperties properties) {
this.properties = properties;
this.projectDocumentationUpdater.setReleaserProperties(properties);
this.releaseTrainContentsUpdater.setReleaserProperties(properties);
}
}

116
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdater.java Normal file
View File

@@ -0,0 +1,116 @@
package org.springframework.cloud.release.internal.docs;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.ReleaserPropertiesAware;
import org.springframework.cloud.release.internal.git.ProjectGitHandler;
import org.springframework.cloud.release.internal.pom.ProjectVersion;
/**
* @author Marcin Grzejszczak
*/
class ProjectDocumentationUpdater implements ReleaserPropertiesAware {
private static final String SC_STATIC_URL = "http://cloud.spring.io/spring-cloud-static/";
private static final Logger log = LoggerFactory.getLogger(ProjectDocumentationUpdater.class);
private final ProjectGitHandler gitHandler;
private ReleaserProperties properties;
ProjectDocumentationUpdater(ReleaserProperties properties,
ProjectGitHandler gitHandler) {
this.gitHandler = gitHandler;
this.properties = properties;
}
/**
* Updates the documentation repository if current release train version is greater or equal
* than the one stored in the repo.
*
* @param currentProject
* @param springCloudReleaseBranch
* @return {@link File cloned temporary directory} - {@code null} if wrong version is used
*/
File updateDocsRepo(ProjectVersion currentProject, String springCloudReleaseBranch) {
if (!properties.getGit().isUpdateDocumentationRepo()) {
log.info("Will not update documentation repository, since the switch to do so "
+ "is off. Set [releaser.git.update-documentation-repo] to [true] to change that");
return null;
}
if (!currentProject.isReleaseOrServiceRelease()) {
log.info("Will not update documentation repository for non release or service release [{}]", currentProject.version);
return null;
}
File documentationProject = this.gitHandler.cloneDocumentationProject();
log.debug("Cloning the doc project to [{}]", documentationProject);
String pathToIndexHtml = "current/index.html";
File indexHtml = new File(documentationProject, pathToIndexHtml);
if (!indexHtml.exists()) {
throw new IllegalStateException("index.html is not present at [" + pathToIndexHtml + "]");
}
return updateTheDocsRepo(springCloudReleaseBranch, documentationProject, indexHtml);
}
private File updateTheDocsRepo(String springCloudReleaseBranch, File documentationProject, File indexHtml) {
try {
String indexHtmlText = readIndexHtmlContents(indexHtml);
int index = indexHtmlText.indexOf(SC_STATIC_URL);
if (index == -1) {
throw new IllegalStateException("The URL to the documentation repo not found in the index.html file");
}
int beginIndex = index + SC_STATIC_URL.length();
String storedReleaseTrainLine = indexHtmlText.substring(beginIndex);
String storedReleaseTrain = storedReleaseTrainLine.substring(0, storedReleaseTrainLine.indexOf("/"));
String firstLetterOfReleaseTrain = String.valueOf(storedReleaseTrain.charAt(0));
String currentReleaseTrainVersion = branchToReleaseVersion(springCloudReleaseBranch);
String firstLetterOfCurrentReleaseTrain = String.valueOf(currentReleaseTrainVersion.charAt(0));
boolean newerOrEqualReleaseTrain = (!storedReleaseTrain.equals(currentReleaseTrainVersion)) && firstLetterOfCurrentReleaseTrain
.compareToIgnoreCase(firstLetterOfReleaseTrain) >= 0;
if (!newerOrEqualReleaseTrain) {
log.info("Current release train [{}] is not newer than the stored one [{}]",
currentReleaseTrainVersion, storedReleaseTrain);
return documentationProject;
}
return pushCommitedChanges(currentReleaseTrainVersion, documentationProject,
indexHtml, indexHtmlText, storedReleaseTrain);
}
catch (IOException e) {
throw new IllegalStateException(e);
}
}
private String branchToReleaseVersion(String springCloudReleaseBranch) {
if (springCloudReleaseBranch.startsWith("v")) {
return springCloudReleaseBranch.substring(1);
}
return springCloudReleaseBranch;
}
private File pushCommitedChanges(String currentReleaseTrainVersion,
File documentationProject, File indexHtml, String indexHtmlText,
String storedReleaseTrain) throws IOException {
String replacedIndexHtml = indexHtmlText.replace(storedReleaseTrain, currentReleaseTrainVersion);
Files.write(indexHtml.toPath(), replacedIndexHtml.getBytes());
log.info("Stored the release train [{}] in [{}]",
currentReleaseTrainVersion, indexHtml.getAbsolutePath());
this.gitHandler.commit(documentationProject, "Updating the link to the current version to [" + currentReleaseTrainVersion + "]");
this.gitHandler.pushCurrentBranch(documentationProject);
log.info("Committed and pushed changes to the documentation project");
return documentationProject;
}
String readIndexHtmlContents(File indexHtml) throws IOException {
return new String(Files.readAllBytes(indexHtml.toPath()));
}
@Override
public void setReleaserProperties(ReleaserProperties properties) {
this.properties = properties;
}
}

37
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContents.java Normal file
View File

@@ -0,0 +1,37 @@
package org.springframework.cloud.release.internal.docs;
import java.util.List;
import java.util.Objects;
public class ReleaseTrainContents {
final Title title;
final List<Row> rows;
ReleaseTrainContents(Title title, List<Row> rows) {
this.title = title;
this.rows = rows;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ReleaseTrainContents contents = (ReleaseTrainContents) o;
return Objects.equals(this.title, contents.title) &&
Objects.equals(this.rows, contents.rows);
}
@Override
public int hashCode() {
return Objects.hash(this.title, this.rows);
}
public Title getTitle() {
return this.title;
}
public List<Row> getRows() {
return this.rows;
}
}

249
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdater.java Normal file
View File

@@ -0,0 +1,249 @@
package org.springframework.cloud.release.internal.docs;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.github.jknack.handlebars.Template;
import com.google.common.collect.ImmutableMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.ReleaserPropertiesAware;
import org.springframework.cloud.release.internal.git.ProjectGitHandler;
import org.springframework.cloud.release.internal.pom.ProjectVersion;
import org.springframework.cloud.release.internal.pom.Projects;
import org.springframework.cloud.release.internal.tech.HandlebarsHelper;
import org.springframework.util.StringUtils;
/**
* @author Marcin Grzejszczak
*/
class ReleaseTrainContentsUpdater implements ReleaserPropertiesAware {
private static final Logger log = LoggerFactory
.getLogger(ReleaseTrainContentsUpdater.class);
private ReleaserProperties properties;
private final ReleaseTrainContentsGitHandler handler;
private final ReleaseTrainContentsParser parser;
private final ReleaseTrainContentsGenerator generator;
ReleaseTrainContentsUpdater(ReleaserProperties properties, ProjectGitHandler handler) {
this.properties = properties;
this.handler = new ReleaseTrainContentsGitHandler(handler);
this.parser = new ReleaseTrainContentsParser();
this.generator = new ReleaseTrainContentsGenerator(this.properties);
}
/**
* Updates the project page if current release train version is greater or equal
* than the one stored in the repo.
*
* @param projects
* @return {@link File cloned temporary directory} - {@code null} if wrong version is used or the switch is turned off
*/
File updateProjectRepo(Projects projects) {
if (!this.properties.getGit().isUpdateSpringProject()) {
log.info("Will not update the Spring Project cause the switch is turned off. Set [releaser.git.update-spring-project=true].");
return null;
}
File releaseTrainProject = this.handler.cloneSpringDocProject();
File index = new File(releaseTrainProject, "index.html");
ReleaseTrainContents contents = this.parser.parse(index);
String newContents = this.generator.releaseTrainContents(contents, projects);
if (StringUtils.isEmpty(newContents)) {
log.info("No changes to commit to the Spring Project page.");
return releaseTrainProject;
}
return pushNewContents(projects, releaseTrainProject, index, newContents);
}
private File pushNewContents(Projects projects, File releaseTrainProject,
File index, String newContents) {
try {
log.debug("Storing new contents to the page");
Files.write(index.toPath(), newContents.getBytes());
log.info("Successfully stored new contents of the page");
this.handler.commitAndPushChanges(releaseTrainProject,
this.generator.currentReleaseTrainProject(projects));
return releaseTrainProject;
}
catch (IOException e) {
throw new IllegalStateException(e);
}
}
@Override
public void setReleaserProperties(ReleaserProperties properties) {
this.properties = properties;
this.generator.setReleaserProperties(properties);
}
}
/**
* @author Marcin Grzejszczak
*/
class ReleaseTrainContentsGenerator implements ReleaserPropertiesAware {
private static final Logger log = LoggerFactory
.getLogger(ReleaseTrainContentsGenerator.class);
private static final String SPRING_PROJECT_TEMPLATE = "spring-project";
private ReleaserProperties properties;
private final File projectOutput;
ReleaseTrainContentsGenerator(ReleaserProperties properties) {
this.properties = properties;
this.projectOutput = new File("target/index.html");
}
String releaseTrainContents(ReleaseTrainContents currentContents, Projects projects) {
String trainProject = this.properties.getMetaRelease().getReleaseTrainProjectName();
ProjectVersion currentReleaseTrainProject = currentReleaseTrainProject(projects);
ProjectVersion lastGa = new ProjectVersion(trainProject, currentContents.title.lastGaTrainName);
ProjectVersion currentGa = new ProjectVersion(trainProject, currentContents.title.currentGaTrainName);
ReleaseTrainContents newReleaseTrainContents = updateReleaseTrainContentsIfNecessary(currentContents, projects,
currentReleaseTrainProject, lastGa, currentGa);
if (!currentContents.equals(newReleaseTrainContents)) {
Template template = HandlebarsHelper.template(this.properties.getTemplate()
.getTemplateFolder(), SPRING_PROJECT_TEMPLATE);
return generate(this.projectOutput, template, newReleaseTrainContents);
}
log.warn("Current release train [{}] is neither last [{}] or current [{}] or the projects haven't changed. Will not update the contents",
currentReleaseTrainProject.version, lastGa, currentGa);
return "";
}
ProjectVersion currentReleaseTrainProject(Projects projects) {
return projects.forName(this.properties.getMetaRelease().getReleaseTrainProjectName());
}
private String generate(File contentOutput, Template template, ReleaseTrainContents releaseTrainContents) {
try {
Map<String, Object> map = ImmutableMap.<String, Object>builder()
.put("lastGaTrainName", releaseTrainContents.title.lastGaTrainName)
.put("currentGaTrainName", releaseTrainContents.title.currentGaTrainName)
.put("currentSnapshotTrainName", releaseTrainContents.title.currentSnapshotTrainName)
.put("projects", releaseTrainContents.rows)
.build();
String contents = template.apply(map);
Files.write(contentOutput.toPath(), contents.getBytes());
return contents;
}
catch (IOException e) {
throw new IllegalStateException(e);
}
}
private ReleaseTrainContents updateReleaseTrainContentsIfNecessary(ReleaseTrainContents currentContents, Projects projects,
ProjectVersion currentReleaseTrainProject, ProjectVersion lastGa, ProjectVersion currentGa) {
ReleaseTrainContents newReleaseTrainContents = currentContents;
// current GA is greater than the last GA
if (greaterMinorOfLastGaReleaseTrain(currentReleaseTrainProject, lastGa)) {
Title title = new Title(currentReleaseTrainProject.version, currentContents.title.currentGaTrainName,
currentContents.title.currentSnapshotTrainName);
return updatedReleaseTrainContents(currentContents, projects, title, true);
} else if (currentReleaseTrainProject.isSameReleaseTrainName(currentGa.version)) {
Title title = new Title(currentContents.title.lastGaTrainName, currentReleaseTrainProject.isReleaseOrServiceRelease() ?
currentReleaseTrainProject.version : currentContents.title.currentGaTrainName, currentReleaseTrainProject.isSnapshot() ?
currentReleaseTrainProject.version : currentContents.title.currentSnapshotTrainName);
return updatedReleaseTrainContents(currentContents, projects, title, false);
}
return newReleaseTrainContents;
}
private boolean greaterMinorOfLastGaReleaseTrain(ProjectVersion currentReleaseTrainProject, ProjectVersion lastGa) {
return currentReleaseTrainProject.isSameReleaseTrainName(lastGa.version) &&
currentReleaseTrainProject.isReleaseOrServiceRelease() &&
currentReleaseTrainProject.compareToReleaseTrainName(lastGa.version) > 0;
}
private ReleaseTrainContents updatedReleaseTrainContents(ReleaseTrainContents currentContents, Projects projects,
Title title, boolean lastGa) {
List<Row> rows = Row.fromProjects(projects, lastGa);
return new ReleaseTrainContents(
title, currentContents.rows.stream().map(current -> {
Row projectRow = rows.stream().filter(row ->
current.componentName.equals(row.componentName)).findFirst().orElse(current);
if (projectRow == current) {
return projectRow;
}
return from(current, projectRow);
}).collect(Collectors.toCollection(LinkedList::new)));
}
private Row from(Row current, Row project) {
return new Row(current.componentName, StringUtils.hasText(project.lastGaVersion) ?
project.lastGaVersion : current.lastGaVersion,
StringUtils.hasText(project.currentGaVersion) ?
project.currentGaVersion : current.currentGaVersion,
StringUtils.hasText(project.currentSnapshotVersion) ?
project.currentSnapshotVersion : current.currentSnapshotVersion);
}
@Override
public void setReleaserProperties(ReleaserProperties properties) {
this.properties = properties;
}
}
class ReleaseTrainContentsGitHandler {
private static final Logger log = LoggerFactory.getLogger(ReleaseTrainContentsGitHandler.class);
private static final String PROJECT_PAGE_UPDATED_COMMIT_MSG = "Updating project page to release train [%s]";
private final ProjectGitHandler handler;
ReleaseTrainContentsGitHandler(ProjectGitHandler handler) {
this.handler = handler;
}
// clones the project and checks out the branch
File cloneSpringDocProject() {
return this.handler.cloneSpringDocProject();
}
void commitAndPushChanges(File repo, ProjectVersion releaseTrain) {
log.debug("Committing and pushing changes");
this.handler.commit(repo, String.format(PROJECT_PAGE_UPDATED_COMMIT_MSG, releaseTrain.version));
this.handler.pushCurrentBranch(repo);
}
}
class ReleaseTrainContentsParser {
private static final Logger log = LoggerFactory
.getLogger(ReleaseTrainContentsParser.class);
ReleaseTrainContents parse(File rawHtml) {
try {
String contents = new String(Files.readAllBytes(rawHtml.toPath()));
String[] split = contents.split("<!-- (BEGIN|END) COMPONENTS -->");
if (split.length != 3) {
log.warn("The page is missing the components table markers. Please add [<!-- BEGIN COMPONENTS -->] and [<!-- END COMPONENTS -->] to the file.");
return null;
}
String table = split[1];
String[] components = table.trim().split("\n");
String[] titleRow = components[0].trim().split("\\|");
Title title = new Title(titleRow);
List<Row> rows = new LinkedList<>();
for (int i = 2; i < components.length; i++) {
String[] splitRow = components[i].split("\\|");
rows.add(new Row(splitRow));
}
return new ReleaseTrainContents(title, rows);
}
catch (IOException e) {
throw new IllegalStateException(e);
}
}
}

81
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/Row.java Normal file
View File

@@ -0,0 +1,81 @@
package org.springframework.cloud.release.internal.docs;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.springframework.cloud.release.internal.pom.ProjectVersion;
import org.springframework.cloud.release.internal.pom.Projects;
/**
* @author Marcin Grzejszczak
*/
public class Row {
final String componentName;
final String lastGaVersion;
final String currentGaVersion;
final String currentSnapshotVersion;
Row(String[] row) {
int initialIndex = row.length == 4 ? 0 : 1;
this.componentName = row[initialIndex].trim();
this.lastGaVersion = row[initialIndex + 1].trim();
this.currentGaVersion = row[initialIndex + 2].trim();
this.currentSnapshotVersion = row[initialIndex + 3].trim();
}
Row(String componentName, String lastGaVersion, String currentGaVersion, String currentSnapshotVersion) {
this.componentName = componentName.trim();
this.lastGaVersion = lastGaVersion.trim();
this.currentGaVersion = currentGaVersion.trim();
this.currentSnapshotVersion = currentSnapshotVersion.trim();
}
static List<Row> fromProjects(Projects projects, boolean lastGa) {
return projects
.stream()
.map(v -> new Row(v.projectName, lastGa ? versionOrEmptyForGa(v) : "",
!lastGa ? versionOrEmptyForGa(v) : "", v.isSnapshot() ? v.version : ""))
.collect(Collectors.toCollection(LinkedList::new));
}
private static String versionOrEmptyForGa(ProjectVersion v) {
return v.isReleaseOrServiceRelease() ?
v.version : "";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Row row = (Row) o;
return Objects.equals(this.componentName, row.componentName) &&
Objects.equals(this.lastGaVersion, row.lastGaVersion) &&
Objects.equals(this.currentGaVersion, row.currentGaVersion) &&
Objects.equals(this.currentSnapshotVersion, row.currentSnapshotVersion);
}
@Override
public int hashCode() {
return Objects
.hash(this.componentName, this.lastGaVersion,
this.currentGaVersion, this.currentSnapshotVersion);
}
public String getComponentName() {
return this.componentName;
}
public String getLastGaVersion() {
return this.lastGaVersion;
}
public String getCurrentGaVersion() {
return this.currentGaVersion;
}
public String getCurrentSnapshotVersion() {
return this.currentSnapshotVersion;
}
}

55
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/Title.java Normal file
View File

@@ -0,0 +1,55 @@
package org.springframework.cloud.release.internal.docs;
import java.util.Objects;
/**
* @author Marcin Grzejszczak
*/
public class Title {
final String lastGaTrainName;
final String currentGaTrainName;
final String currentSnapshotTrainName;
Title(String[] row) {
int initialIndex = row.length == 4 ? 1 : 2;
this.lastGaTrainName = row[initialIndex].trim();
this.currentGaTrainName = row[initialIndex + 1].trim();
this.currentSnapshotTrainName = row[initialIndex + 2].trim();
}
Title(String lastGaTrainName, String currentGaTrainName, String currentSnapshotTrainName) {
this.lastGaTrainName = lastGaTrainName.trim();
this.currentGaTrainName = currentGaTrainName.trim();
this.currentSnapshotTrainName = currentSnapshotTrainName.trim();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Title title = (Title) o;
return Objects.equals(this.lastGaTrainName, title.lastGaTrainName) &&
Objects.equals(this.currentGaTrainName, title.currentGaTrainName) &&
Objects
.equals(this.currentSnapshotTrainName, title.currentSnapshotTrainName);
}
@Override
public int hashCode() {
return Objects
.hash(this.lastGaTrainName, this.currentGaTrainName, this.currentSnapshotTrainName);
}
public String getLastGaTrainName() {
return this.lastGaTrainName;
}
public String getCurrentGaTrainName() {
return this.currentGaTrainName;
}
public String getCurrentSnapshotTrainName() {
return this.currentSnapshotTrainName;
}
}

38
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/ProjectGitHandler.java
View File

@@ -6,6 +6,7 @@ import java.nio.file.Files;
import org.eclipse.jgit.transport.URIish;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.ReleaserPropertiesAware;
import org.springframework.cloud.release.internal.pom.ProjectVersion;
@@ -25,10 +26,9 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
private static final String PRE_RELEASE_MSG = "Update SNAPSHOT to %s";
private static final String POST_RELEASE_MSG = "Going back to snapshots";
private static final String POST_RELEASE_BUMP_MSG = "Bumping versions to %s after release";
private ReleaserProperties properties;
private final GithubMilestones githubMilestones;
private final GithubIssues githubIssues;
private ReleaserProperties properties;
public ProjectGitHandler(ReleaserProperties properties) {
this.properties = properties;
@@ -41,7 +41,8 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
if (version.isSnapshot()) {
log.info("Snapshot version [{}] found. Will only commit the changed poms", version);
gitRepo.commit(MSG);
} else {
}
else {
log.info("NON-snapshot version [{}] found. Will commit the changed poms, tag the version and push the tag", version);
gitRepo.commit(String.format(PRE_RELEASE_MSG, version.version));
String tagName = "v" + version.version;
@@ -53,8 +54,10 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
public void commitAfterBumpingVersions(File project, ProjectVersion version) {
if (version.isSnapshot()) {
log.info("Snapshot version [{}] found. Will only commit the changed poms", version);
commit(project, String.format(POST_RELEASE_BUMP_MSG, version.bumpedVersion()));
} else {
commit(project, String
.format(POST_RELEASE_BUMP_MSG, version.bumpedVersion()));
}
else {
log.info("Non snapshot version [{}] found. Won't do anything", version);
}
}
@@ -69,8 +72,20 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
}
public File cloneDocumentationProject() {
File clonedProject = cloneProject(this.properties.getGit().getDocumentationUrl());
checkout(clonedProject, this.properties.getGit().getDocumentationBranch());
return cloneAndCheckOut(this.properties.getGit()
.getDocumentationUrl(), this.properties.getGit()
.getDocumentationBranch());
}
public File cloneSpringDocProject() {
return cloneAndCheckOut(this.properties.getGit()
.getSpringProjectUrl(), this.properties.getGit()
.getSpringProjectBranch());
}
private File cloneAndCheckOut(String springProjectUrl, String springProjectUrlBranch) {
File clonedProject = cloneProject(springProjectUrl);
checkout(clonedProject, springProjectUrlBranch);
return clonedProject;
}
@@ -115,7 +130,8 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
new File(properties.getGit().getCloneDestinationDir()) :
Files.createTempDirectory("releaser").toFile();
return gitRepo(destinationDir).cloneProject(new URIish(url));
} catch (Exception e) {
}
catch (Exception e) {
throw new IllegalStateException(e);
}
}
@@ -137,7 +153,8 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
if (splitVersion.length == 3) {
// [2,3,4] -> 2.3.x
return splitVersion[0] + "." + splitVersion[1] + ".x";
} else if (splitVersion.length == 1) {
}
else if (splitVersion.length == 1) {
// [Camden] -> [Camden.x]
return splitVersion[0];
}
@@ -178,7 +195,8 @@ public class ProjectGitHandler implements ReleaserPropertiesAware {
return new GitRepo(workingDir, this.properties);
}
@Override public void setReleaserProperties(ReleaserProperties properties) {
@Override
public void setReleaserProperties(ReleaserProperties properties) {
this.properties = properties;
}
}

50
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProjectVersion.java
View File

@@ -107,6 +107,34 @@ public class ProjectVersion {
splitThis[0].equals(splitThat[0]) && splitThis[1].equals(splitThat[1]);
}
public boolean isSameReleaseTrainName(String version) {
assertVersionSet();
String[] splitThis = this.version.split("\\.");
String[] splitThat = version.split("\\.");
return splitThis[0].compareToIgnoreCase(splitThat[0]) == 0;
}
private void assertVersionSet() {
if (this.version == null) {
throw new IllegalStateException("Version is not set");
}
}
public int compareToReleaseTrainName(String version) {
assertVersionSet();
String[] split = version.split("\\.");
String thatName = split[0];
String thatValue = split[1];
String[] thisSplit = this.version.split("\\.");
String thisName = thisSplit[0];
String thisValue = thisSplit[1];
int nameComparison = thisName.compareTo(thatName);
if (nameComparison != 0) {
return nameComparison;
}
return new VersionNumber(thisValue).compareTo(new VersionNumber(thatValue));
}
@Override public String toString() {
return this.version;
}
@@ -124,3 +152,25 @@ public class ProjectVersion {
return Objects.hash(this.projectName);
}
}
class VersionNumber implements Comparable<VersionNumber> {
private final String version;
VersionNumber(String version) {
this.version = version;
}
@Override
public int compareTo(VersionNumber o) {
char thisFirst = this.version.toLowerCase().charAt(0);
char thatFirst = o.version.toLowerCase().charAt(0);
// B < M < RC < R < S
int charComparison = Character.compare(thisFirst, thatFirst);
if (charComparison != 0) {
return charComparison;
}
Integer thisNumber = Integer.valueOf(this.version.replaceAll("\\D+",""));
Integer thatNumber = Integer.valueOf(o.version.replaceAll("\\D+",""));
return thisNumber.compareTo(thatNumber);
}
}

27
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/tech/HandlebarsHelper.java Normal file
View File

@@ -0,0 +1,27 @@
package org.springframework.cloud.release.internal.tech;
import java.io.IOException;
import com.github.jknack.handlebars.Handlebars;
import com.github.jknack.handlebars.Template;
import com.github.jknack.handlebars.helper.StringHelpers;
import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
/**
* @author Marcin Grzejszczak
*/
public final class HandlebarsHelper {
public static Template template(String templateSubFolder, String templateName) {
try {
Handlebars handlebars = new Handlebars(new ClassPathTemplateLoader("/templates/" +
templateSubFolder));
handlebars.registerHelper("replace", StringHelpers.replace);
handlebars.registerHelper("capitalizeFirst", StringHelpers.capitalizeFirst);
return handlebars.compile(templateName);
}
catch (IOException e) {
throw new IllegalStateException(e);
}
}
}

11
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/TemplateGenerator.java
View File

@@ -12,6 +12,7 @@ import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.ReleaserPropertiesAware;
import org.springframework.cloud.release.internal.git.ProjectGitHandler;
import org.springframework.cloud.release.internal.pom.Projects;
import org.springframework.cloud.release.internal.tech.HandlebarsHelper;
/**
* @author Marcin Grzejszczak
@@ -101,15 +102,7 @@ public class TemplateGenerator implements ReleaserPropertiesAware {
}
private Template template(String template) {
try {
Handlebars handlebars = new Handlebars(new ClassPathTemplateLoader("/templates/" +
this.props.getTemplate().getTemplateFolder()));
handlebars.registerHelper("replace", StringHelpers.replace);
handlebars.registerHelper("capitalizeFirst", StringHelpers.capitalizeFirst);
return handlebars.compile(template);
} catch (IOException e) {
throw new IllegalStateException(e);
}
return HandlebarsHelper.template(this.props.getTemplate().getTemplateFolder(), template);
}
@Override public void setReleaserProperties(ReleaserProperties properties) {

357
spring-cloud-release-tools-core/src/main/resources/templates/cloud/spring-project.hbs Normal file
View File

@@ -0,0 +1,357 @@
---
# The name of your project
title: Spring Cloud
badges:
# Customize your project's badges. Delete any entries that do not apply.
custom:
- name: Source (GitHub)
url: https://github.com/spring-cloud
icon: github
- name: StackOverflow
url: http://stackoverflow.com/questions/tagged/spring-cloud
icon: stackoverflow
---
<!DOCTYPE HTML>
<html lang="en-US">
{% capture billboard_description %}
Spring Cloud provides tools for developers to quickly build some of
the common patterns in distributed systems (e.g. configuration
management, service discovery, circuit breakers, intelligent routing,
micro-proxy, control bus, one-time tokens, global locks, leadership
election, distributed sessions, cluster state). Coordination of
distributed systems leads to boiler plate patterns, and using Spring
Cloud developers can quickly stand up services and applications that
implement those patterns. They will work well in any distributed
environment, including the developer's own laptop, bare metal data
centres, and managed platforms such as Cloud Foundry.
{% endcapture %}
{% capture main_content %}
Spring Cloud builds on Spring Boot by providing a bunch of libraries
that enhance the behaviour of an application when added to the
classpath. You can take advantage of the basic default behaviour to
get started really quickly, and then when you need to, you can
configure or extend to create a custom solution.
<span id="quick-start"></span>
## Quick Start
The release train label (see below) is actually only used explicitly
in one artifact: "spring-cloud-dependencies" (all the others have
normal numeric release labels tied to their parent project). The
dependencies POM is the one you can use as a BOM for dependency
management. Example using the latest version with the config client
and eureka (change the artifact ids to pull in other starters):
{% include download_widget.md %}
## Features
Spring Cloud focuses on providing good out of box experience for typical use cases and extensibility mechanism to cover others.
* Distributed/versioned configuration
* Service registration and discovery
* Routing
* Service-to-service calls
* Load balancing
* Circuit Breakers
* Global locks
* Leadership election and cluster state
* Distributed messaging
Spring Cloud takes a very declarative approach, and often you get a
lot of fetaures with just a classpath change and/or an
annotation. Example application that is a discovery client:
```java
@SpringBootApplication
@EnableDiscoveryClient
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
<a name="main-projects"></a>
## Main Projects
<!-- Spring Cloud Config -->
{% capture project_description %}
Centralized external configuration management backed by a git repository. The configuration resources map directly to Spring `Environment` but could be used by non-Spring applications if desired.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-config" repo_url="http://github.com/spring-cloud/spring-cloud-config" project_title="Spring Cloud Config" project_description=project_description %}
<!-- Spring Cloud Netflix -->
{% capture project_description %}
Integration with various Netflix OSS components (Eureka, Hystrix, Zuul, Archaius, etc.).
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-netflix" repo_url="http://github.com/spring-cloud/spring-cloud-netflix" project_title="Spring Cloud Netflix" project_description=project_description %}
<!-- Spring Cloud Bus -->
{% capture project_description %}
An event bus for linking services and service instances together with distributed messaging. Useful for propagating state changes across a cluster (e.g. config change events).
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-bus" repo_url="http://github.com/spring-cloud/spring-cloud-bus" project_title="Spring Cloud Bus" project_description=project_description %}
<!-- Spring Cloud Cloudfoundry -->
{% capture project_description %}
Integrates your application with Pivotal Cloud Foundry. Provides a service discovery implementation and also makes it easy to implement SSO and OAuth2 protected resources.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-cloudfoundry" repo_url="http://github.com/spring-cloud/spring-cloud-cloudfoundry" project_title="Spring Cloud for Cloud Foundry" project_description=project_description %}
<!-- Spring Cloud Open Service Broker -->
{% capture project_description %}
Provides a starting point for building a service broker that implements the Open Service Broker API.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-open-service-broker/" repo_url="http://github.com/spring-cloud/spring-cloud-open-service-broker" project_title="Spring Cloud Open Service Broker" project_description=project_description %}
<!-- Spring Cloud Cluster -->
{% capture project_description %}
Leadership election and common stateful patterns with an abstraction and implementation for Zookeeper, Redis, Hazelcast, Consul.
{% endcapture %}
{% include project_block.md site_url="/spring-cloud" repo_url="http://github.com/spring-cloud/spring-cloud-cluster" project_title="Spring Cloud Cluster" project_description=project_description %}
<!-- Spring Cloud Consul -->
{% capture project_description %}
Service discovery and configuration management with Hashicorp Consul.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-consul" repo_url="http://github.com/spring-cloud/spring-cloud-consul" project_title="Spring Cloud Consul" project_description=project_description %}
<!-- Spring Cloud Security -->
{% capture project_description %}
Provides support for load-balanced OAuth2 rest client and authentication header relays in a Zuul proxy.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-security" repo_url="http://github.com/spring-cloud/spring-cloud-security" project_title="Spring Cloud Security" project_description=project_description %}
<!-- Spring Cloud Sleuth -->
{% capture project_description %}
Distributed tracing for Spring Cloud applications, compatible with Zipkin, HTrace and log-based (e.g. ELK) tracing.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-sleuth" repo_url="http://github.com/spring-cloud/spring-cloud-sleuth" project_title="Spring Cloud Sleuth" project_description=project_description %}
<!-- Spring Cloud Data Flow -->
{% capture project_description %}
A cloud-native orchestration service for composable microservice applications on modern runtimes. Easy-to-use DSL, drag-and-drop GUI, and REST-APIs together simplifies the overall orchestration of microservice based data pipelines.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-dataflow" repo_url="https://github.com/spring-cloud/spring-cloud-dataflow" project_title="Spring Cloud Data Flow" project_description=project_description %}
<!-- Spring Cloud Stream -->
{% capture project_description %}
A lightweight event-driven microservices framework to quickly build applications that can connect to external systems. Simple declarative model to send and receive messages using Apache Kafka or RabbitMQ between Spring Boot apps.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-stream" repo_url="http://github.com/spring-cloud/spring-cloud-stream" project_title="Spring Cloud Stream" project_description=project_description %}
<!-- Spring Cloud Stream App Starters -->
{% capture project_description %}
Spring Cloud Stream App Starters are Spring Boot based Spring Integration applications that provide integration with external systems.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-stream-app-starters" repo_url="https://github.com/spring-cloud/spring-cloud-stream-app-starters" project_title="Spring Cloud Stream App Starters" project_description=project_description %}
<!-- Spring Cloud Task -->
{% capture project_description %}
A short-lived microservices framework to quickly build applications that perform finite amounts of data processing. Simple declarative for adding both functional and non-functional features to Spring Boot apps.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-task" repo_url="http://github.com/spring-cloud/spring-cloud-task" project_title="Spring Cloud Task" project_description=project_description %}
<!-- Spring Cloud Task App Starters -->
{% capture project_description %}
Spring Cloud Task App Starters are Spring Boot applications that may be any process including Spring Batch jobs that do not run forever, and they end/stop after a finite period of data processing.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-task-app-starters" repo_url="https://github.com/spring-cloud/spring-cloud-task-app-starters" project_title="Spring Cloud Task App Starters" project_description=project_description %}
<!-- Spring Cloud Zookeeper -->
{% capture project_description %}
Service discovery and configuration management with Apache Zookeeper.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-zookeeper" repo_url="http://github.com/spring-cloud/spring-cloud-zookeeper" project_title="Spring Cloud Zookeeper" project_description=project_description %}
<!-- Spring Cloud AWS -->
{% capture project_description %}
Easy integration with hosted Amazon Web Services. It offers a convenient way to interact with AWS provided services using well-known Spring idioms and APIs, such as the messaging or caching API. Developers can build their application around the hosted services without having to care about infrastructure or maintenance.
{% endcapture %}
{% capture site_url %}
{{ site.projects_site_url }}/spring-cloud-aws
{% endcapture %}
{% include project_block.md site_url=site_url repo_url="http://github.com/spring-cloud/spring-cloud-aws" project_title="Spring Cloud for Amazon Web Services" project_description=project_description %}
<!-- Spring Cloud Connectors -->
{% capture project_description %}
Makes it easy for PaaS applications in a variety of platforms to connect to backend services like
databases and message brokers (the project formerly known as "Spring Cloud").
{% endcapture %}
{% capture site_url %}
{{ site.projects_site_url }}/spring-cloud-connectors
{% endcapture %}
{% include project_block.md site_url=site_url repo_url="http://github.com/spring-cloud/spring-cloud-connectors" project_title="Spring Cloud Connectors" project_description=project_description %}
<!-- Spring Cloud Starters -->
{% capture project_description %}
Spring Boot-style starter projects to ease dependency management for consumers of Spring Cloud. (Discontinued as a project and merged with the other projects after Angel.SR2.)
{% endcapture %}
{% include project_block.md site_url="http://github.com/spring-cloud/spring-cloud-starters" repo_url="http://github.com/spring-cloud/spring-cloud-starters" project_title="Spring Cloud Starters" project_description=project_description %}
<!-- Spring Cloud CLI -->
{% capture project_description %}
Spring Boot CLI plugin for creating Spring Cloud component applications quickly in Groovy
{% endcapture %}
{% include project_block.md site_url="http://github.com/spring-cloud/spring-cloud-cli" repo_url="http://github.com/spring-cloud/spring-cloud-cli" project_title="Spring Cloud CLI" project_description=project_description %}
<!-- Spring Cloud Contract -->
{% capture project_description %}
Spring Cloud Contract is an umbrella project holding solutions that help users in successfully implementing the Consumer Driven Contracts approach.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-contract" repo_url="http://github.com/spring-cloud/spring-cloud-contract" project_title="Spring Cloud Contract" project_description=project_description %}
<!-- Spring Cloud Gateway -->
{% capture project_description %}
Spring Cloud Gateway is an intelligent and programmable router based on Project Reactor.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-gateway" repo_url="http://github.com/spring-cloud/spring-cloud-gateway" project_title="Spring Cloud Gateway" project_description=project_description %}
<!-- Spring Cloud OpenFeign -->
{% capture project_description %}
Spring Cloud OpenFeign provides integrations for Spring Boot apps through autoconfiguration and binding to the Spring Environment and other Spring programming model idioms.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-openfeign" repo_url="http://github.com/spring-cloud/spring-cloud-openfeign" project_title="Spring Cloud OpenFeign" project_description=project_description %}
<!-- Spring Cloud Pipelines -->
{% capture project_description %}
Spring Cloud Pipelines provides an opinionated deployment pipeline with steps to ensure that your application can be deployed in zero downtime fashion and easilly rolled back of something goes wrong.
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-pipelines" repo_url="http://github.com/spring-cloud/spring-cloud-pipelines" project_title="Spring Cloud Pipelines" project_description=project_description %}
<!-- Spring Cloud Function -->
{% capture project_description %}
Spring Cloud Function promotes the implementation of business logic via functions. It supports a uniform programming model across serverless providers, as well as the ability to run standalone (locally or in a PaaS).
{% endcapture %}
{% include project_block.md site_url="http://cloud.spring.io/spring-cloud-function" repo_url="http://github.com/spring-cloud/spring-cloud-function" project_title="Spring Cloud Function" project_description=project_description %}
## Release Trains
Spring Cloud is an umbrella project consisting of independent projects with, in principle, different
release cadences. To manage the portfolio a BOM (Bill of Materials) is published with a curated
set of dependencies on the individual project (see below). The release trains have names, not
versions, to avoid confusion with the sub-projects. The names are an alphabetic sequence (so
you can sort them chronologically) with names of London Tube stations ("Angel" is the first
release, "Brixton" is the second). When point releases of the individual projects accumulate to
a critical mass, or if there is a critical bug in one of them that needs to be available to everyone,
the release train will push out "service releases" with names ending ".SRX", where "X"
is a number.
Release train contents:
<!-- BEGIN COMPONENTS -->
|Component |{{lastGaTrainName}}|{{currentGaTrainName}}|{{currentSnapshotTrainName}}|
|--------------------------------------|-----------------|---------------------|------------------------|
{{#each projects}} |{{componentName}}|{{lastGaVersion}}|{{currentGaVersion}}|{{currentSnapshotVersion}}|
{{/each}}
<!-- END COMPONENTS -->
Finchley builds and works with Spring Boot 2.0.x, and is not expected
to work with Spring Boot 1.5.x.
Note: The Dalston release train will [reach end-of-life](https://spring.io/blog/2018/06/19/spring-cloud-finchley-release-is-available) in December 2018. Edgware will follow the end-of-life cycle of Spring Boot 1.5.x.
The Dalston and Edgware release trains build on Spring Boot 1.5.x, and
are not expected to work with Spring Boot 2.0.x.
NOTE: The Camden release train was [marked end-of-life](https://spring.io/blog/2018/06/19/spring-cloud-finchley-release-is-available).
The Camden release train builds on Spring Boot 1.4.x, but is also
tested with 1.5.x.
NOTE: The Brixton and Angel release trains were [marked end-of-life](https://spring.io/blog/2017/07/21/spring-cloud-dalston-sr2-is-available-now#end-of-life-for-angel-and-brixton-release-trains)
(EOL) in July 2017.
The Brixton release train builds on Spring Boot 1.3.x, but is also
tested with 1.4.x.
The Angel release train builds on Spring Boot 1.2.x, and is
incompatible in some areas with Spring Boot 1.3.x. Brixton builds on
Spring Boot 1.3.x and is similarly incompatible with 1.2.x. Some
libraries and most apps built on Angel will run fine on Brixton, but
changes will be required anywhere that the OAuth2 features from
spring-cloud-security 1.0.x are used (they were mostly moved to Spring
Boot in 1.3.0).
Use your dependency management tools to control the version. If you
are using Maven remember that the first version declared wins, so
declare the BOMs in order, with the first one usually being the most
recent (e.g. if you want to use Spring Boot 1.3.6 with Brixton.RELEASE, put
the Boot BOM first). The same rule applies to Gradle if you use the
Spring dependency management plugin.
> NOTE: The release train contains a
> `spring-cloud-dependencies` as well as the
> `spring-cloud-starter-parent`. You can use the parent as you would
> the `spring-boot-starter-parent` (if you are using Maven).
> If you only need dependency management, the "dependencies"
> version is a BOM-only version of the same thing (it just
> contains dependency management and no plugin declarations
> or direct references to Spring or Spring Boot). If you are
> using the Spring Boot parent POM, then you can use the BOM from
> Spring Cloud. The opposite is not true: using the Cloud parent
> makes it impossible, or at least unreliable, to also use the
> Boot BOM to change the version of Spring Boot and its dependencies.
> NOTE: If you find anything wrong or outdated on this page, please open an issue in [this](https://github.com/spring-projects/spring-cloud) repo.
{% endcapture %}
{% capture related_resources %}
### Sample Projects
* [Config Server](https://github.com/spring-cloud-samples/configserver)
* [Service Registry](https://github.com/spring-cloud-samples/eureka)
* [Circuit Breaker Dashboard](https://github.com/spring-cloud-samples/hystrix-dashboard)
* [Business Application](https://github.com/spring-cloud-samples/customers-stores) (Customers and Stores)
* [OAuth2 Authorization Server](https://github.com/spring-cloud-samples/authserver)
* [OAuth2 SSO Client](https://github.com/spring-cloud-samples/sso)
* [Integration Test Samples](https://github.com/spring-cloud-samples/tests)
* [Spring Cloud Contract Samples](https://github.com/spring-cloud-samples/spring-cloud-contract-samples)
{% endcapture %}
{% include project_page.html %}
</html>