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

Updates for new sagain api, s-c-build 3.1 and boot 2.6 (#243)

Browse Source 
Updates releaser to use spring cloud build 3.1.0

Transitively uses boot 2.6

Updates releaser to use new Sagan API

Fixes gh-196
Fixes gh-194
This commit is contained in:
Spencer Gibb
2022-02-18 14:29:17 -05:00
committed by GitHub
parent 2e7d318f13
commit e83cda4fed
195 changed files with 2914 additions and 4881 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
releaser-spring/pom.xml
View File

@@ -59,6 +59,11 @@
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<profiles>

4
releaser-spring/src/main/java/releaser/ReleaserCommandLineRunner.java
View File

@@ -32,8 +32,8 @@ public class ReleaserCommandLineRunner implements CommandLineRunner {
private final Parser parser;
public ReleaserCommandLineRunner(SpringReleaser releaser,
ExecutionResultHandler executionResultHandler, Parser parser) {
public ReleaserCommandLineRunner(SpringReleaser releaser, ExecutionResultHandler executionResultHandler,
Parser parser) {
this.releaser = releaser;
this.executionResultHandler = executionResultHandler;
this.parser = parser;

9
releaser-spring/src/main/java/releaser/internal/buildsystem/BuildsystemConfiguration.java
View File

@@ -36,8 +36,7 @@ class BuildsystemConfiguration {
return new MavenBomParser(releaserProperties, customBomParsers(customBomParsers));
}
private List<CustomBomParser> customBomParsers(
List<CustomBomParser> customBomParsers) {
private List<CustomBomParser> customBomParsers(List<CustomBomParser> customBomParsers) {
return customBomParsers == null ? new ArrayList<>() : customBomParsers;
}
@@ -45,14 +44,12 @@ class BuildsystemConfiguration {
@ConditionalOnMissingBean
BomParser gradleBomParser(ReleaserProperties releaserProperties,
@Autowired(required = false) List<CustomBomParser> customBomParsers) {
return new GradleBomParser(releaserProperties,
customBomParsers(customBomParsers));
return new GradleBomParser(releaserProperties, customBomParsers(customBomParsers));
}
@Bean
@ConditionalOnMissingBean
ProjectPomUpdater pomUpdater(ReleaserProperties releaserProperties,
List<BomParser> bomParsers) {
ProjectPomUpdater pomUpdater(ReleaserProperties releaserProperties, List<BomParser> bomParsers) {
return new ProjectPomUpdater(releaserProperties, bomParsers);
}

3
releaser-spring/src/main/java/releaser/internal/github/GithubConfiguration.java
View File

@@ -31,8 +31,7 @@ class GithubConfiguration {
BeanPostProcessor cachingGithubBeanPostProcessor() {
return new BeanPostProcessor() {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof RtGithub) {
return new CachingGithub((Github) bean);
}

12
releaser-spring/src/main/java/releaser/internal/options/Options.java
View File

@@ -60,14 +60,13 @@ public class Options implements Serializable {
*/
public String range = "";
Options(Boolean metaRelease, Boolean fullRelease, Boolean interactive, Boolean dryRun,
List<String> taskNames, String startFrom, String range) {
Options(Boolean metaRelease, Boolean fullRelease, Boolean interactive, Boolean dryRun, List<String> taskNames,
String startFrom, String range) {
this.metaRelease = metaRelease;
this.fullRelease = fullRelease;
this.interactive = interactive;
this.dryRun = dryRun;
this.taskNames = taskNames.stream().map(this::removeQuotingChars)
.collect(Collectors.toList());
this.taskNames = taskNames.stream().map(this::removeQuotingChars).collect(Collectors.toList());
this.startFrom = removeQuotingChars(startFrom);
this.range = removeQuotingChars(range);
}
@@ -81,9 +80,8 @@ public class Options implements Serializable {
@Override
public String toString() {
return "Options{" + "metaRelease=" + this.metaRelease + ", fullRelease="
+ this.fullRelease + ", interactive=" + this.interactive + ", dryRun="
+ this.dryRun + ", taskNames=" + this.taskNames + ", startFrom='"
return "Options{" + "metaRelease=" + this.metaRelease + ", fullRelease=" + this.fullRelease + ", interactive="
+ this.interactive + ", dryRun=" + this.dryRun + ", taskNames=" + this.taskNames + ", startFrom='"
+ this.startFrom + '\'' + ", range='" + this.range + '\'' + '}';
}

4
releaser-spring/src/main/java/releaser/internal/options/OptionsBuilder.java
View File

@@ -71,8 +71,8 @@ public class OptionsBuilder {
}
public Options options() {
return new Options(this.metaRelease, this.fullRelease, this.interactive,
this.dryRun, this.taskNames, this.startFrom, this.range);
return new Options(this.metaRelease, this.fullRelease, this.interactive, this.dryRun, this.taskNames,
this.startFrom, this.range);
}
}

17
releaser-spring/src/main/java/releaser/internal/sagan/SaganConfiguration.java
View File

@@ -16,8 +16,6 @@
package releaser.internal.sagan;
import java.util.List;
import releaser.internal.ReleaserProperties;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@@ -44,8 +42,7 @@ class SaganConfiguration {
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(value = "releaser.sagan.update-sagan", havingValue = "false",
matchIfMissing = true)
@ConditionalOnProperty(value = "releaser.sagan.update-sagan", havingValue = "false", matchIfMissing = true)
SaganClient noOpSaganClient() {
return new SaganClient() {
@Override
@@ -59,14 +56,13 @@ class SaganConfiguration {
}
@Override
public Release deleteRelease(String projectName, String releaseVersion) {
return null;
public boolean deleteRelease(String projectName, String releaseVersion) {
return false;
}
@Override
public Project updateRelease(String projectName,
List<ReleaseUpdate> releaseUpdate) {
return null;
public boolean addRelease(String projectName, ReleaseInput releaseInput) {
return false;
}
@Override
@@ -81,8 +77,7 @@ class SaganConfiguration {
"In order to connect to Sagan you need to pass the Github OAuth token. "
+ "You can do it via the [--releaser.git.oauth-token=...] "
+ "command line argument or an env variable [export RELEASER_GIT_OAUTH_TOKEN=...].");
return new RestTemplateBuilder()
.basicAuthentication(properties.getGit().getOauthToken(), "").build();
return new RestTemplateBuilder().basicAuthentication(properties.getGit().getOauthToken(), "").build();
}
}

68
releaser-spring/src/main/java/releaser/internal/spring/Arguments.java
View File

@@ -80,34 +80,29 @@ public final class Arguments implements Serializable {
*/
public final List<ProcessedProject> processedProjects;
private Arguments(ProjectToRun thisProject, Projects projects,
ProjectVersion currentProjectFromBom) {
private Arguments(ProjectToRun thisProject, Projects projects, ProjectVersion currentProjectFromBom) {
this.project = thisProject.thisProjectFolder;
this.projects = projects;
this.originalVersion = thisProject.originalVersion;
log.info("Creating Arguments for: " + thisProject.name() + "; Original version: "
+ this.originalVersion);
log.info("Creating Arguments for: " + thisProject.name() + "; Original version: " + this.originalVersion);
Assert.isTrue(this.originalVersion != null && this.originalVersion.version != null,
"Original Version must not be null for project: " + thisProject.name());
this.versionFromBom = currentProjectFromBom;
this.properties = thisProject.thisProjectReleaserProperties;
this.options = thisProject.options;
this.projectToRun = thisProject;
this.processedProjects = new LinkedList<>(Collections.singletonList(
new ProcessedProject(thisProject.thisProjectReleaserProperties,
this.versionFromBom, this.originalVersion)));
this.processedProjects = new LinkedList<>(Collections.singletonList(new ProcessedProject(
thisProject.thisProjectReleaserProperties, this.versionFromBom, this.originalVersion)));
}
// in this case the project will be the BOM
private Arguments(ProjectToRun thisProject,
List<ProcessedProject> processedProjects) {
private Arguments(ProjectToRun thisProject, List<ProcessedProject> processedProjects) {
this.project = thisProject.thisProjectFolder;
this.projects = new Projects(processedProjects.stream()
.map(p -> p.newProjectVersion).collect(Collectors.toSet()));
this.projects = new Projects(
processedProjects.stream().map(p -> p.newProjectVersion).collect(Collectors.toSet()));
this.originalVersion = thisProject.originalVersion;
log.info("Creating Arguments for: " + thisProject.name() + "; Original version: "
+ this.originalVersion);
log.info("Creating Arguments for: " + thisProject.name() + "; Original version: " + this.originalVersion);
Assert.isTrue(this.originalVersion != null && this.originalVersion.version != null,
"Original Version must not be null for project: " + thisProject.name());
this.versionFromBom = thisProject.thisProjectVersionFromBom;
@@ -118,41 +113,28 @@ public final class Arguments implements Serializable {
}
public static Arguments forProject(ProjectToRun thisProject) {
return new Arguments(thisProject,
thisProject.allProjectsFromBom.allProjectVersionsFromBom,
return new Arguments(thisProject, thisProject.allProjectsFromBom.allProjectVersionsFromBom,
thisProject.allProjectsFromBom.currentProjectFromBom);
}
public static Arguments forPostRelease(ReleaserProperties properties,
ProjectsToRun projectsToRun) {
List<ProjectToRun> projects = projectsToRun.stream()
.map(ProjectToRun.ProjectToRunSupplier::get)
public static Arguments forPostRelease(ReleaserProperties properties, ProjectsToRun projectsToRun) {
List<ProjectToRun> projects = projectsToRun.stream().map(ProjectToRun.ProjectToRunSupplier::get)
.collect(Collectors.toCollection(LinkedList::new));
List<ProcessedProject> processedProjects = projectsToRunToProcessedProject(
projects);
ProjectToRun releaseTrainProject = projects.stream()
.filter(p -> isReleaseTrainProject(properties, p)).findFirst()
.orElseThrow(
() -> new IllegalStateException("Missing release train version"));
List<ProcessedProject> processedProjects = projectsToRunToProcessedProject(projects);
ProjectToRun releaseTrainProject = projects.stream().filter(p -> isReleaseTrainProject(properties, p))
.findFirst().orElseThrow(() -> new IllegalStateException("Missing release train version"));
return new Arguments(releaseTrainProject, processedProjects);
}
private static boolean isReleaseTrainProject(ReleaserProperties properties,
ProjectToRun p) {
return p.originalVersion.projectName
.equals(properties.getMetaRelease().getReleaseTrainProjectName())
|| properties.getMetaRelease().getReleaseTrainDependencyNames()
.contains(p.originalVersion.projectName)
|| p.name()
.equals(properties.getMetaRelease().getReleaseTrainProjectName());
private static boolean isReleaseTrainProject(ReleaserProperties properties, ProjectToRun p) {
return p.originalVersion.projectName.equals(properties.getMetaRelease().getReleaseTrainProjectName())
|| properties.getMetaRelease().getReleaseTrainDependencyNames().contains(p.originalVersion.projectName)
|| p.name().equals(properties.getMetaRelease().getReleaseTrainProjectName());
}
private static List<ProcessedProject> projectsToRunToProcessedProject(
List<ProjectToRun> projects) {
return projects.stream()
.map(p -> new ProcessedProject(p.thisProjectReleaserProperties,
p.thisProjectVersionFromBom, p.originalVersion))
.collect(Collectors.toCollection(LinkedList::new));
private static List<ProcessedProject> projectsToRunToProcessedProject(List<ProjectToRun> projects) {
return projects.stream().map(p -> new ProcessedProject(p.thisProjectReleaserProperties,
p.thisProjectVersionFromBom, p.originalVersion)).collect(Collectors.toCollection(LinkedList::new));
}
public ProjectVersion releaseTrain() {
@@ -161,11 +143,9 @@ public final class Arguments implements Serializable {
@Override
public String toString() {
return "Arguments{" + "project=" + project + ", projects=" + projects
+ ", originalVersion=" + originalVersion + ", versionFromBom="
+ versionFromBom + ", properties=" + properties + ", options=" + options
+ ", projectToRun=" + projectToRun + ", processedProjects="
+ processedProjects + '}';
return "Arguments{" + "project=" + project + ", projects=" + projects + ", originalVersion=" + originalVersion
+ ", versionFromBom=" + versionFromBom + ", properties=" + properties + ", options=" + options
+ ", projectToRun=" + projectToRun + ", processedProjects=" + processedProjects + '}';
}
}

22
releaser-spring/src/main/java/releaser/internal/spring/BatchConfiguration.java
View File

@@ -62,8 +62,7 @@ class BatchConfiguration {
@Bean
@ConditionalOnMissingBean(ExecutionResultHandler.class)
SpringBatchExecutionResultHandler springBatchExecutionResultHandler(
BuildReportHandler buildReportHandler,
SpringBatchExecutionResultHandler springBatchExecutionResultHandler(BuildReportHandler buildReportHandler,
ConfigurableApplicationContext context) {
return new SpringBatchExecutionResultHandler(buildReportHandler, context);
}
@@ -77,15 +76,12 @@ class BatchConfiguration {
@Bean
@ConditionalOnMissingBean
FlowRunner flowRunner(StepBuilderFactory stepBuilderFactory,
JobBuilderFactory jobBuilderFactory,
FlowRunner flowRunner(StepBuilderFactory stepBuilderFactory, JobBuilderFactory jobBuilderFactory,
ProjectsToRunFactory projectsToRunFactory, JobLauncher jobLauncher,
FlowRunnerTaskExecutorSupplier flowRunnerTaskExecutorSupplier,
ConfigurableApplicationContext context, ReleaserProperties releaserProperties,
BuildReportHandler reportHandler) {
return new SpringBatchFlowRunner(stepBuilderFactory, jobBuilderFactory,
projectsToRunFactory, jobLauncher, flowRunnerTaskExecutorSupplier,
context, releaserProperties, reportHandler);
FlowRunnerTaskExecutorSupplier flowRunnerTaskExecutorSupplier, ConfigurableApplicationContext context,
ReleaserProperties releaserProperties, BuildReportHandler reportHandler) {
return new SpringBatchFlowRunner(stepBuilderFactory, jobBuilderFactory, projectsToRunFactory, jobLauncher,
flowRunnerTaskExecutorSupplier, context, releaserProperties, reportHandler);
}
@Bean
@@ -110,8 +106,7 @@ class BatchConfiguration {
protected JobExplorer createJobExplorer() throws Exception {
JobExplorerFactoryBean jobExplorerFactoryBean = new JobExplorerFactoryBean();
jobExplorerFactoryBean.setDataSource(dataSource);
jobExplorerFactoryBean
.setSerializer(myJackson2ExecutionContextStringSerializer);
jobExplorerFactoryBean.setSerializer(myJackson2ExecutionContextStringSerializer);
jobExplorerFactoryBean.afterPropertiesSet();
return jobExplorerFactoryBean.getObject();
}
@@ -120,8 +115,7 @@ class BatchConfiguration {
protected JobRepository createJobRepository() throws Exception {
JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
jobRepositoryFactoryBean.setDataSource(dataSource);
jobRepositoryFactoryBean
.setSerializer(myJackson2ExecutionContextStringSerializer);
jobRepositoryFactoryBean.setSerializer(myJackson2ExecutionContextStringSerializer);
jobRepositoryFactoryBean.setTransactionManager(transactionManager);
jobRepositoryFactoryBean.afterPropertiesSet();
return jobRepositoryFactoryBean.getObject();

38
releaser-spring/src/main/java/releaser/internal/spring/DefaultSpringReleaser.java
View File

@@ -38,10 +38,8 @@ class DefaultSpringReleaser implements SpringReleaser {
private final FlowRunner flowRunner;
DefaultSpringReleaser(ReleaserProperties properties,
OptionsAndPropertiesFactory optionsAndPropertiesFactory,
ProjectsToRunFactory projectsToRunFactory,
TasksToRunFactory tasksToRunFactory, FlowRunner flowRunner) {
DefaultSpringReleaser(ReleaserProperties properties, OptionsAndPropertiesFactory optionsAndPropertiesFactory,
ProjectsToRunFactory projectsToRunFactory, TasksToRunFactory tasksToRunFactory, FlowRunner flowRunner) {
this.properties = properties;
this.optionsAndPropertiesFactory = optionsAndPropertiesFactory;
this.projectsToRunFactory = projectsToRunFactory;
@@ -59,25 +57,22 @@ class DefaultSpringReleaser implements SpringReleaser {
@Override
public ExecutionResult release(Options options) {
OptionsAndProperties optionsAndProperties = prepareOptionsAndProperties(options,
this.properties);
OptionsAndProperties optionsAndProperties = prepareOptionsAndProperties(options, this.properties);
// order matters! Tasks will mutate options and properties
TasksToRun releaseTasksToRun = releaseTasksFromOptions(optionsAndProperties);
ProjectsToRun projectsToRun = releaseProjects(optionsAndProperties);
ExecutionResult releaseTasksExecutionResult = runReleaseTasks(
optionsAndProperties, projectsToRun, releaseTasksToRun);
ExecutionResult releaseTasksExecutionResult = runReleaseTasks(optionsAndProperties, projectsToRun,
releaseTasksToRun);
if (releaseTasksExecutionResult.isFailure()) {
return releaseTasksExecutionResult;
}
TasksToRun postReleaseTrainTasksToRun = postReleaseTrainTasksFromOptions(
optionsAndProperties);
ExecutionResult postReleaseTrainTasksExecutionResult = runPostReleaseTasks(
optionsAndProperties, postReleaseTrainTasksToRun);
TasksToRun postReleaseTrainTasksToRun = postReleaseTrainTasksFromOptions(optionsAndProperties);
ExecutionResult postReleaseTrainTasksExecutionResult = runPostReleaseTasks(optionsAndProperties,
postReleaseTrainTasksToRun);
return releaseTasksExecutionResult.merge(postReleaseTrainTasksExecutionResult);
}
private OptionsAndProperties prepareOptionsAndProperties(Options options,
ReleaserProperties properties) {
private OptionsAndProperties prepareOptionsAndProperties(Options options, ReleaserProperties properties) {
return this.optionsAndPropertiesFactory.get(properties, options);
}
@@ -89,21 +84,20 @@ class DefaultSpringReleaser implements SpringReleaser {
return this.tasksToRunFactory.release(options);
}
private TasksToRun postReleaseTrainTasksFromOptions(
OptionsAndProperties optionsAndProperties) {
private TasksToRun postReleaseTrainTasksFromOptions(OptionsAndProperties optionsAndProperties) {
return this.tasksToRunFactory.postRelease(optionsAndProperties.options);
}
private ExecutionResult runReleaseTasks(OptionsAndProperties optionsAndProperties,
ProjectsToRun projectsToRun, TasksToRun tasksToRun) {
return this.flowRunner.runReleaseTasks(optionsAndProperties.options,
optionsAndProperties.properties, projectsToRun, tasksToRun);
private ExecutionResult runReleaseTasks(OptionsAndProperties optionsAndProperties, ProjectsToRun projectsToRun,
TasksToRun tasksToRun) {
return this.flowRunner.runReleaseTasks(optionsAndProperties.options, optionsAndProperties.properties,
projectsToRun, tasksToRun);
}
private ExecutionResult runPostReleaseTasks(OptionsAndProperties optionsAndProperties,
TasksToRun postReleaseTasksToRun) {
return this.flowRunner.runPostReleaseTrainTasks(optionsAndProperties.options,
optionsAndProperties.properties, "postRelease", postReleaseTasksToRun);
return this.flowRunner.runPostReleaseTrainTasks(optionsAndProperties.options, optionsAndProperties.properties,
"postRelease", postReleaseTasksToRun);
}
}

3
releaser-spring/src/main/java/releaser/internal/spring/ExecutionResultReport.java
View File

@@ -42,8 +42,7 @@ public class ExecutionResultReport {
}
public ExecutionResultReport(String projectName, String shortName, String description,
Class<? extends ReleaserTask> releaserTaskType, String state,
List<Throwable> exceptions) {
Class<? extends ReleaserTask> releaserTaskType, String state, List<Throwable> exceptions) {
this.projectName = projectName;
this.shortName = shortName;
this.description = description;

13
releaser-spring/src/main/java/releaser/internal/spring/FlowRunner.java
View File

@@ -33,8 +33,7 @@ public interface FlowRunner {
* @param releaserTask - the task to run
* @return the decision on what to do with the task
*/
default Decision beforeTask(Options options, ReleaserProperties properties,
ReleaserTask releaserTask) {
default Decision beforeTask(Options options, ReleaserProperties properties, ReleaserTask releaserTask) {
return Decision.CONTINUE;
}
@@ -45,8 +44,7 @@ public interface FlowRunner {
* @param releaserTask - the task to run
* @return the decision on what to do with the task
*/
default Decision afterTask(Options options, ReleaserProperties properties,
ReleaserTask releaserTask) {
default Decision afterTask(Options options, ReleaserProperties properties, ReleaserTask releaserTask) {
return Decision.CONTINUE;
}
@@ -58,8 +56,8 @@ public interface FlowRunner {
* @param tasksToRun - set of release tasks to run for each project
* @return the result of release execution
*/
ExecutionResult runReleaseTasks(Options options, ReleaserProperties properties,
ProjectsToRun projectToRuns, TasksToRun tasksToRun);
ExecutionResult runReleaseTasks(Options options, ReleaserProperties properties, ProjectsToRun projectToRuns,
TasksToRun tasksToRun);
/**
* Runs the post release tasks.
@@ -69,8 +67,7 @@ public interface FlowRunner {
* @param tasksToRun - set of post release tasks to run for each project
* @return the result of release execution
*/
ExecutionResult runPostReleaseTrainTasks(Options options,
ReleaserProperties properties, String executingTaskName,
ExecutionResult runPostReleaseTrainTasks(Options options, ReleaserProperties properties, String executingTaskName,
TasksToRun tasksToRun);
/**

80
releaser-spring/src/main/java/releaser/internal/spring/OptionsParser.java
View File

@@ -51,8 +51,7 @@ class OptionsParser implements Parser {
private final ConfigurableApplicationContext context;
OptionsParser(List<ReleaserTask> allTasks,
List<SingleProjectReleaserTask> singleProjectReleaserTasks,
OptionsParser(List<ReleaserTask> allTasks, List<SingleProjectReleaserTask> singleProjectReleaserTasks,
ConfigurableApplicationContext context) {
this.allTasks = allTasks;
this.singleProjectReleaserTasks = singleProjectReleaserTasks;
@@ -66,39 +65,32 @@ class OptionsParser implements Parser {
log.info("Got following args <{}>", (Object[]) args);
try {
ArgumentAcceptingOptionSpec<Boolean> metaReleaseOpt = parser
.acceptsAll(Arrays.asList("x", "meta-release"),
"Do you want to do the meta release?")
.acceptsAll(Arrays.asList("x", "meta-release"), "Do you want to do the meta release?")
.withRequiredArg().ofType(Boolean.class).defaultsTo(false);
ArgumentAcceptingOptionSpec<Boolean> fullReleaseOpt = parser
.acceptsAll(Arrays.asList("f", "full-release"),
"Do you want to do the full release of a single project?")
.withOptionalArg().ofType(Boolean.class).defaultsTo(false);
ArgumentAcceptingOptionSpec<Boolean> interactiveOpt = parser.acceptsAll(
Arrays.asList("i", "interactive"),
"Do you want to set the properties from the command line of a single project?")
ArgumentAcceptingOptionSpec<Boolean> interactiveOpt = parser
.acceptsAll(Arrays.asList("i", "interactive"),
"Do you want to set the properties from the command line of a single project?")
.withRequiredArg().ofType(Boolean.class).defaultsTo(true);
ArgumentAcceptingOptionSpec<Boolean> dryRunOpt = parser.acceptsAll(
Arrays.asList("dr", "dry-run"),
ArgumentAcceptingOptionSpec<Boolean> dryRunOpt = parser.acceptsAll(Arrays.asList("dr", "dry-run"),
"Do you want to do the release / meta release with build and install projects locally only?")
.withRequiredArg().ofType(Boolean.class).defaultsTo(false);
LinkedList<ReleaserTask> singleProjectReleaseTasks = this.allTasks.stream()
.filter(releaserTask -> releaserTask instanceof SingleProjectReleaserTask)
.collect(Collectors.toCollection(LinkedList::new));
singleProjectReleaseTasks.forEach(task -> parser
.acceptsAll(Arrays.asList(task.shortName(), task.name()),
task.description())
.withOptionalArg());
ArgumentAcceptingOptionSpec<String> startFromOpt = parser.acceptsAll(
Arrays.asList("a", "start-from"),
"Starts all release task starting "
.acceptsAll(Arrays.asList(task.shortName(), task.name()), task.description()).withOptionalArg());
ArgumentAcceptingOptionSpec<String> startFromOpt = parser
.acceptsAll(Arrays.asList("a", "start-from"), "Starts all release task starting "
+ "from the given task. Requires passing the task name (either one letter or the full name)")
.withRequiredArg().ofType(String.class);
ArgumentAcceptingOptionSpec<String> taskNamesOpt = parser
.acceptsAll(Arrays.asList("tn", "task-names"),
"Starts all release task for the given task names")
.acceptsAll(Arrays.asList("tn", "task-names"), "Starts all release task for the given task names")
.withRequiredArg().ofType(String.class).defaultsTo("");
ArgumentAcceptingOptionSpec<String> rangeOpt = parser.acceptsAll(
Arrays.asList("r", "range"),
ArgumentAcceptingOptionSpec<String> rangeOpt = parser.acceptsAll(Arrays.asList("r", "range"),
"Runs release tasks from the given range. Requires passing "
+ "the task names with a hyphen. The first task is inclusive, "
+ "the second inclusive. E.g. 's-m' would mean running 'snapshot', "
@@ -115,32 +107,25 @@ class OptionsParser implements Parser {
Boolean interactive = options.valueOf(interactiveOpt);
Boolean dryRun = options.valueOf(dryRunOpt);
Boolean fullRelease = options.has(fullReleaseOpt);
List<String> providedTaskNames = StringUtils.hasText(options
.valueOf(taskNamesOpt)) ? Arrays.asList(
removeQuotingChars(options.valueOf(taskNamesOpt)).split(","))
: new ArrayList<>();
providedTaskNames = providedTaskNames.stream().map(this::removeQuotingChars)
.collect(Collectors.toList());
List<String> providedTaskNames = StringUtils.hasText(options.valueOf(taskNamesOpt))
? Arrays.asList(removeQuotingChars(options.valueOf(taskNamesOpt)).split(",")) : new ArrayList<>();
providedTaskNames = providedTaskNames.stream().map(this::removeQuotingChars).collect(Collectors.toList());
log.info("Passed tasks {} from command line", providedTaskNames);
List<String> allTaskNames = singleProjectReleaseTasks.stream()
.map(ReleaserTask::name).collect(Collectors.toList());
List<String> tasksFromOptions = singleProjectReleaseTasks.stream().filter(
task -> options.has(task.name()) || options.has(task.shortName()))
.map(ReleaserTask::name).collect(Collectors.toList());
List<String> allTaskNames = singleProjectReleaseTasks.stream().map(ReleaserTask::name)
.collect(Collectors.toList());
List<String> tasksFromOptions = singleProjectReleaseTasks.stream()
.filter(task -> options.has(task.name()) || options.has(task.shortName())).map(ReleaserTask::name)
.collect(Collectors.toList());
if (providedTaskNames.isEmpty()) {
providedTaskNames.addAll(tasksFromOptions.isEmpty() && !metaRelease
? allTaskNames : tasksFromOptions);
providedTaskNames.addAll(tasksFromOptions.isEmpty() && !metaRelease ? allTaskNames : tasksFromOptions);
}
List<String> taskNames = filterProvidedTaskNames(providedTaskNames,
allTaskNames, metaRelease);
List<String> taskNames = filterProvidedTaskNames(providedTaskNames, allTaskNames, metaRelease);
String startFrom = options.valueOf(startFromOpt);
String range = options.valueOf(rangeOpt);
Options buildOptions = new OptionsBuilder().metaRelease(metaRelease)
.fullRelease(fullRelease).interactive(interactive).dryRun(dryRun)
.taskNames(taskNames).startFrom(startFrom).range(range).options();
log.info(
"\n\nWill use the following options to process the project\n\n{}\n\n",
buildOptions);
Options buildOptions = new OptionsBuilder().metaRelease(metaRelease).fullRelease(fullRelease)
.interactive(interactive).dryRun(dryRun).taskNames(taskNames).startFrom(startFrom).range(range)
.options();
log.info("\n\nWill use the following options to process the project\n\n{}\n\n", buildOptions);
return buildOptions;
}
catch (Exception e) {
@@ -149,8 +134,8 @@ class OptionsParser implements Parser {
}
}
List<String> filterProvidedTaskNames(List<String> providedTaskNames,
List<String> allTaskNames, boolean metaRelease) {
List<String> filterProvidedTaskNames(List<String> providedTaskNames, List<String> allTaskNames,
boolean metaRelease) {
if (metaRelease) {
return providedTaskNames;
}
@@ -170,8 +155,7 @@ class OptionsParser implements Parser {
System.err.println(e.getMessage());
e.printStackTrace();
System.err.println(intro());
System.err.println(
"java -jar releaser-spring-1.0.0.BUILD-SNAPSHOT.jar [options...] ");
System.err.println("java -jar releaser-spring-1.0.0.BUILD-SNAPSHOT.jar [options...] ");
try {
parser.printHelpOn(System.err);
}
@@ -194,15 +178,13 @@ class OptionsParser implements Parser {
private String intro() {
return "\nHere you can find the list of tasks in order for a single project\n\n["
+ this.singleProjectReleaserTasks.stream().map(ReleaserTask::name)
.collect(Collectors.joining(","))
+ this.singleProjectReleaserTasks.stream().map(ReleaserTask::name).collect(Collectors.joining(","))
+ "]\n\n";
}
private String examples() {
return "\nExamples of usage:\n\n" + "Run 'build' & 'commit' & 'deploy'\n"
+ "java -jar jar.jar -b -c -d\n\n" + "Start from 'push'\n"
+ "java -jar releaser.jar -a push\n\n" + "Range 'docs' -> 'push'\n"
return "\nExamples of usage:\n\n" + "Run 'build' & 'commit' & 'deploy'\n" + "java -jar jar.jar -b -c -d\n\n"
+ "Start from 'push'\n" + "java -jar releaser.jar -a push\n\n" + "Range 'docs' -> 'push'\n"
+ "java -jar releaser.jar -r o-p\n\n" + "\n\n";
}

6
releaser-spring/src/main/java/releaser/internal/spring/ProjectToRun.java
View File

@@ -64,8 +64,7 @@ public class ProjectToRun implements Serializable {
*/
public final Options options;
public ProjectToRun(File thisProjectFolder, ProjectsFromBom allProjectsFromBom,
ProjectVersion originalVersion,
public ProjectToRun(File thisProjectFolder, ProjectsFromBom allProjectsFromBom, ProjectVersion originalVersion,
ReleaserProperties thisProjectReleaserProperties, Options options) {
this.thisProjectFolder = thisProjectFolder;
this.allProjectsFromBom = allProjectsFromBom;
@@ -100,8 +99,7 @@ public class ProjectToRun implements Serializable {
* Supplier of a project to run. Since retrieval of a project may require cloning it,
* we will cache the cloned location instead of cloning it each time.
*/
public static class ProjectToRunSupplier
implements Supplier<ProjectToRun>, Closeable {
public static class ProjectToRunSupplier implements Supplier<ProjectToRun>, Closeable {
private static final Map<String, ProjectToRun> CACHE = new ConcurrentHashMap<>();

3
releaser-spring/src/main/java/releaser/internal/spring/ProjectsFromBom.java
View File

@@ -34,8 +34,7 @@ public class ProjectsFromBom {
*/
public final ProjectVersion currentProjectFromBom;
public ProjectsFromBom(Projects allProjectVersionsFromBom,
ProjectVersion currentProjectFromBom) {
public ProjectsFromBom(Projects allProjectVersionsFromBom, ProjectVersion currentProjectFromBom) {
this.allProjectVersionsFromBom = allProjectVersionsFromBom;
this.currentProjectFromBom = currentProjectFromBom;
}

81
releaser-spring/src/main/java/releaser/internal/spring/ProjectsToRunFactory.java
View File

@@ -62,19 +62,15 @@ class ProjectsToRunFactory implements Closeable {
Options options = optionsAndProperties.options;
ReleaserProperties properties = optionsAndProperties.properties;
if (!options.metaRelease) {
log.info(
"Single project release picked. Will release only the current project");
log.info("Single project release picked. Will release only the current project");
File projectFolder = projectFolder(properties);
ProjectVersion version = new ProjectVersion(projectFolder);
ProjectsFromBom projectsFromBom = this.versionsToBumpFactory
.withProject(projectFolder);
return new ProjectsToRun(
new ProjectToRun.ProjectToRunSupplier(version.projectName, () -> {
ReleaserProperties changedProps = updatePropertiesIfCustomConfigPresent(
properties.copy(), projectFolder);
return new ProjectToRun(projectFolder, projectsFromBom, version,
changedProps, options);
}));
ProjectsFromBom projectsFromBom = this.versionsToBumpFactory.withProject(projectFolder);
return new ProjectsToRun(new ProjectToRun.ProjectToRunSupplier(version.projectName, () -> {
ReleaserProperties changedProps = updatePropertiesIfCustomConfigPresent(properties.copy(),
projectFolder);
return new ProjectToRun(projectFolder, projectsFromBom, version, changedProps, options);
}));
}
log.info("Meta release picked");
return metaReleaseProjectsToRun(options, properties);
@@ -101,48 +97,39 @@ class ProjectsToRunFactory implements Closeable {
return new File(workingDir);
}
private ProjectsToRun metaReleaseProjectsToRun(Options options,
ReleaserProperties originalProps) {
return metaProjectsToRun(options, originalProps,
metaReleaseProjects(options, originalProps));
private ProjectsToRun metaReleaseProjectsToRun(Options options, ReleaserProperties originalProps) {
return metaProjectsToRun(options, originalProps, metaReleaseProjects(options, originalProps));
}
private ProjectsToRun metaReleasePostReleaseProjectsToRun(Options options,
ReleaserProperties originalProps) {
return metaProjectsToRun(options, originalProps,
allButSkippedProjects(originalProps));
private ProjectsToRun metaReleasePostReleaseProjectsToRun(Options options, ReleaserProperties originalProps) {
return metaProjectsToRun(options, originalProps, allButSkippedProjects(originalProps));
}
private ProjectsToRun metaProjectsToRun(Options options,
ReleaserProperties originalProps, List<String> projectNames) {
return projectNames.stream()
.map(project -> projectSupplier(options, originalProps, project))
private ProjectsToRun metaProjectsToRun(Options options, ReleaserProperties originalProps,
List<String> projectNames) {
return projectNames.stream().map(project -> projectSupplier(options, originalProps, project))
.collect(Collectors.toCollection(ProjectsToRun::new));
}
private ProjectToRun.ProjectToRunSupplier projectSupplier(Options options,
ReleaserProperties originalProps, String project) {
private ProjectToRun.ProjectToRunSupplier projectSupplier(Options options, ReleaserProperties originalProps,
String project) {
return new ProjectToRun.ProjectToRunSupplier(project, () -> {
File clonedProjectFromOrg = this.releaser.clonedProjectFromOrg(project);
ReleaserProperties properties = updatePropertiesIfCustomConfigPresent(
originalProps.copy(), clonedProjectFromOrg);
log.info("Successfully cloned the project [{}] to [{}]", project,
ReleaserProperties properties = updatePropertiesIfCustomConfigPresent(originalProps.copy(),
clonedProjectFromOrg);
log.info("Successfully cloned the project [{}] to [{}]", project, clonedProjectFromOrg);
ProjectVersion originalVersion = new ProjectVersion(clonedProjectFromOrg);
ProjectsFromBom projectsFromBom = this.versionsToBumpFactory
.withProject(clonedProjectFromOrg);
return new ProjectToRun(clonedProjectFromOrg, projectsFromBom,
originalVersion, properties, options);
ProjectsFromBom projectsFromBom = this.versionsToBumpFactory.withProject(clonedProjectFromOrg);
return new ProjectToRun(clonedProjectFromOrg, projectsFromBom, originalVersion, properties, options);
});
}
private ReleaserProperties updatePropertiesIfCustomConfigPresent(
ReleaserProperties copy, File clonedProjectFromOrg) {
private ReleaserProperties updatePropertiesIfCustomConfigPresent(ReleaserProperties copy,
File clonedProjectFromOrg) {
return this.updater.updateProperties(copy, clonedProjectFromOrg);
}
private List<String> metaReleaseProjects(Options options,
ReleaserProperties properties) {
private List<String> metaReleaseProjects(Options options, ReleaserProperties properties) {
List<String> filteredProjects = allButSkippedProjects(properties);
if (StringUtils.hasText(options.startFrom)) {
filteredProjects = filterStartFrom(options, filteredProjects);
@@ -150,15 +137,13 @@ class ProjectsToRunFactory implements Closeable {
else if (!options.taskNames.isEmpty()) {
filteredProjects = filterTaskNames(options, filteredProjects);
}
log.info("\n\n\nFor meta-release, will release the projects {}\n\n\n",
filteredProjects);
log.info("\n\n\nFor meta-release, will release the projects {}\n\n\n", filteredProjects);
return filteredProjects;
}
private List<String> allButSkippedProjects(ReleaserProperties properties) {
List<String> projects = new ArrayList<>(properties.getFixedVersions().keySet());
log.info("List of projects that should not be cloned {}",
properties.getMetaRelease().getProjectsToSkip());
log.info("List of projects that should not be cloned {}", properties.getMetaRelease().getProjectsToSkip());
List<String> filteredProjects = filterProjectsToSkip(projects, properties);
log.info("List of all projects to clone before filtering {}", filteredProjects);
return filteredProjects;
@@ -168,11 +153,8 @@ class ProjectsToRunFactory implements Closeable {
return new ArrayList<>(properties.getFixedVersions().keySet());
}
private List<String> filterProjectsToSkip(List<String> projects,
ReleaserProperties properties) {
return projects
.stream().filter(project -> !properties.getMetaRelease()
.getProjectsToSkip().contains(project))
private List<String> filterProjectsToSkip(List<String> projects, ReleaserProperties properties) {
return projects.stream().filter(project -> !properties.getMetaRelease().getProjectsToSkip().contains(project))
.collect(Collectors.toList());
}
@@ -180,22 +162,19 @@ class ProjectsToRunFactory implements Closeable {
log.info("Start from option provided [{}]", options.startFrom);
int projectIndex = filteredProjects.indexOf(options.startFrom);
if (projectIndex < 0) {
throw new IllegalStateException(
"Project [" + options.startFrom + "] not found");
throw new IllegalStateException("Project [" + options.startFrom + "] not found");
}
if (log.isDebugEnabled()) {
log.debug("Index of project [{}] is [{}]", options.startFrom, projectIndex);
}
filteredProjects = filteredProjects.subList(projectIndex,
filteredProjects.size());
filteredProjects = filteredProjects.subList(projectIndex, filteredProjects.size());
options.startFrom = "";
return filteredProjects;
}
private List<String> filterTaskNames(Options options, List<String> filteredProjects) {
log.info("Task names provided {}", options.taskNames);
filteredProjects = filteredProjects.stream()
.filter(project -> options.taskNames.contains(project))
filteredProjects = filteredProjects.stream().filter(project -> options.taskNames.contains(project))
.collect(Collectors.toList());
options.taskNames = new ArrayList<>();
return filteredProjects;

66
releaser-spring/src/main/java/releaser/internal/spring/ReleaserConfiguration.java
View File

@@ -59,15 +59,14 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
VersionsToBumpFactory versionsToBumpFactory(Releaser releaser,
ReleaserProperties properties) {
VersionsToBumpFactory versionsToBumpFactory(Releaser releaser, ReleaserProperties properties) {
return new VersionsToBumpFactory(releaser, properties);
}
@Bean
@ConditionalOnMissingBean
ProjectsToRunFactory projectsToRunFactory(VersionsToBumpFactory versionsToBumpFactory,
Releaser releaser, ReleaserPropertiesUpdater updater) {
ProjectsToRunFactory projectsToRunFactory(VersionsToBumpFactory versionsToBumpFactory, Releaser releaser,
ReleaserPropertiesUpdater updater) {
return new ProjectsToRunFactory(versionsToBumpFactory, releaser, updater);
}
@@ -80,11 +79,10 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
SpringReleaser springReleaser(OptionsAndPropertiesFactory optionsAndPropertiesFactory,
ProjectsToRunFactory projectsToRunFactory,
TasksToRunFactory tasksToRunFactory, FlowRunner flowRunner,
ProjectsToRunFactory projectsToRunFactory, TasksToRunFactory tasksToRunFactory, FlowRunner flowRunner,
ReleaserProperties properties) {
return new DefaultSpringReleaser(properties, optionsAndPropertiesFactory,
projectsToRunFactory, tasksToRunFactory, flowRunner);
return new DefaultSpringReleaser(properties, optionsAndPropertiesFactory, projectsToRunFactory,
tasksToRunFactory, flowRunner);
}
@Bean
@@ -95,8 +93,7 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
VersionsFetcher versionsFetcher(ProjectPomUpdater updater,
ReleaserProperties properties) {
VersionsFetcher versionsFetcher(ProjectPomUpdater updater, ReleaserProperties properties) {
return new VersionsFetcher(properties, updater);
}
@@ -108,8 +105,7 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
ProjectGitHubHandler projectGitHubHandler(
@Autowired(required = false) List<CustomGithubIssues> customGithubIssues,
ProjectGitHubHandler projectGitHubHandler(@Autowired(required = false) List<CustomGithubIssues> customGithubIssues,
ReleaserProperties properties) {
return new ProjectGitHubHandler(properties,
customGithubIssues != null ? customGithubIssues : new ArrayList<>());
@@ -117,8 +113,7 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
TemplateGenerator templateGenerator(ProjectGitHubHandler handler,
ReleaserProperties properties) {
TemplateGenerator templateGenerator(ProjectGitHubHandler handler, ReleaserProperties properties) {
return new TemplateGenerator(properties, handler);
}
@@ -130,47 +125,39 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
SaganUpdater saganUpdater(SaganClient saganClient,
ReleaserProperties releaserProperties) {
SaganUpdater saganUpdater(SaganClient saganClient, ReleaserProperties releaserProperties) {
return new SaganUpdater(saganClient, releaserProperties);
}
@Bean
@ConditionalOnMissingBean
PostReleaseActions postReleaseActions(ProjectGitHandler handler,
ProjectPomUpdater pomUpdater, GradleUpdater gradleUpdater,
ProjectCommandExecutor projectCommandExecutor,
PostReleaseActions postReleaseActions(ProjectGitHandler handler, ProjectPomUpdater pomUpdater,
GradleUpdater gradleUpdater, ProjectCommandExecutor projectCommandExecutor,
ReleaserProperties releaserProperties, VersionsFetcher versionsFetcher,
ReleaserPropertiesUpdater releaserPropertiesUpdater) {
return new PostReleaseActions(handler, pomUpdater, gradleUpdater,
projectCommandExecutor, releaserProperties, versionsFetcher,
releaserPropertiesUpdater);
return new PostReleaseActions(handler, pomUpdater, gradleUpdater, projectCommandExecutor, releaserProperties,
versionsFetcher, releaserPropertiesUpdater);
}
@Bean
@ConditionalOnMissingBean
DocumentationUpdater documentationUpdater(ProjectGitHandler projectGitHandler,
ReleaserProperties properties, TemplateGenerator templateGenerator,
@Autowired(
required = false) List<CustomProjectDocumentationUpdater> customProjectDocumentationUpdaters) {
DocumentationUpdater documentationUpdater(ProjectGitHandler projectGitHandler, ReleaserProperties properties,
TemplateGenerator templateGenerator,
@Autowired(required = false) List<CustomProjectDocumentationUpdater> customProjectDocumentationUpdaters) {
return new DocumentationUpdater(projectGitHandler, properties, templateGenerator,
customProjectDocumentationUpdaters != null
? customProjectDocumentationUpdaters : new ArrayList<>());
customProjectDocumentationUpdaters != null ? customProjectDocumentationUpdaters : new ArrayList<>());
}
@Bean
@ConditionalOnMissingBean
Releaser releaser(ProjectPomUpdater projectPomUpdater,
ProjectCommandExecutor projectCommandExecutor,
ProjectGitHandler projectGitHandler,
ProjectGitHubHandler projectGitHubHandler,
TemplateGenerator templateGenerator, GradleUpdater gradleUpdater,
SaganUpdater saganUpdater, DocumentationUpdater documentationUpdater,
PostReleaseActions postReleaseActions,
Releaser releaser(ProjectPomUpdater projectPomUpdater, ProjectCommandExecutor projectCommandExecutor,
ProjectGitHandler projectGitHandler, ProjectGitHubHandler projectGitHubHandler,
TemplateGenerator templateGenerator, GradleUpdater gradleUpdater, SaganUpdater saganUpdater,
DocumentationUpdater documentationUpdater, PostReleaseActions postReleaseActions,
ReleaserProperties releaserProperties) {
return new Releaser(releaserProperties, projectPomUpdater, projectCommandExecutor,
projectGitHandler, projectGitHubHandler, templateGenerator, gradleUpdater,
saganUpdater, documentationUpdater, postReleaseActions);
return new Releaser(releaserProperties, projectPomUpdater, projectCommandExecutor, projectGitHandler,
projectGitHubHandler, templateGenerator, gradleUpdater, saganUpdater, documentationUpdater,
postReleaseActions);
}
@Bean
@@ -181,8 +168,7 @@ class ReleaserConfiguration {
@Bean
@ConditionalOnMissingBean
Parser optionsParser(List<ReleaserTask> allTasks,
List<SingleProjectReleaserTask> singleProjectReleaserTasks,
Parser optionsParser(List<ReleaserTask> allTasks, List<SingleProjectReleaserTask> singleProjectReleaserTasks,
ConfigurableApplicationContext context) {
return new OptionsParser(allTasks, singleProjectReleaserTasks, context);
}

58
releaser-spring/src/main/java/releaser/internal/spring/SpringBatchBuildReportHandler.java
View File

@@ -39,8 +39,7 @@ import org.springframework.util.StringUtils;
class SpringBatchBuildReportHandler implements BuildReportHandler {
private static final Logger log = LoggerFactory
.getLogger(SpringBatchExecutionResultHandler.class);
private static final Logger log = LoggerFactory.getLogger(SpringBatchExecutionResultHandler.class);
private final JobExplorer jobExplorer;
@@ -52,34 +51,27 @@ class SpringBatchBuildReportHandler implements BuildReportHandler {
public void reportBuildSummary() {
List<String> jobNames = this.jobExplorer.getJobNames();
List<JobExecution> sortedJobExecutions = jobNames.stream()
.flatMap(name -> this.jobExplorer.findJobInstancesByJobName(name, 0, 100)
.stream())
.flatMap(instance -> this.jobExplorer.getJobExecutions(instance).stream())
.filter(j -> !j.isRunning())
.sorted(Comparator.comparing(JobExecution::getCreateTime))
.collect(Collectors.toList());
List<StepExecution> stepContexts = sortedJobExecutions.stream()
.flatMap(j -> j.getStepExecutions().stream())
.flatMap(name -> this.jobExplorer.findJobInstancesByJobName(name, 0, 100).stream())
.flatMap(instance -> this.jobExplorer.getJobExecutions(instance).stream()).filter(j -> !j.isRunning())
.sorted(Comparator.comparing(JobExecution::getCreateTime)).collect(Collectors.toList());
List<StepExecution> stepContexts = sortedJobExecutions.stream().flatMap(j -> j.getStepExecutions().stream())
.collect(Collectors.toCollection(LinkedList::new));
printTable(buildTable(stepContexts));
}
private List<Table> buildTable(List<StepExecution> stepContexts) {
return stepContexts.stream().map(step -> {
String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")
.format(step.getStartTime());
long millis = ChronoUnit.MILLIS.between(step.getStartTime().toInstant(),
step.getEndTime().toInstant());
String date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(step.getStartTime());
long millis = ChronoUnit.MILLIS.between(step.getStartTime().toInstant(), step.getEndTime().toInstant());
ExecutionContext context = step.getExecutionContext();
ExecutionResultReport entity = (ExecutionResultReport) context.get("entity");
if (entity == null) {
return null;
}
String projectName = TrainPostReleaseReleaserTask.class
.isAssignableFrom(entity.getReleaserTaskType()) ? "postRelease"
: entity.getProjectName();
return new Table(date, time(millis), projectName, entity.getShortName(),
entity.getDescription(), entity.getState(), entity.getExceptions());
String projectName = TrainPostReleaseReleaserTask.class.isAssignableFrom(entity.getReleaserTaskType())
? "postRelease" : entity.getProjectName();
return new Table(date, time(millis), projectName, entity.getShortName(), entity.getDescription(),
entity.getState(), entity.getExceptions());
}).filter(Objects::nonNull).collect(Collectors.toCollection(LinkedList::new));
}
@@ -96,23 +88,20 @@ class SpringBatchBuildReportHandler implements BuildReportHandler {
}
private void printTable(List<Table> table) {
String string = "\n\n***** BUILD REPORT *****\n\n"
+ FlipTableConverters.fromIterable(table, Table.class)
String string = "\n\n***** BUILD REPORT *****\n\n" + FlipTableConverters.fromIterable(table, Table.class)
+ "\n\n***** BUILD REPORT *****\n\n";
List<Table> brokenTasks = table.stream()
.filter(table1 -> StringUtils.hasText(table1.thrownException))
List<Table> brokenTasks = table.stream().filter(table1 -> StringUtils.hasText(table1.thrownException))
.collect(Collectors.toList());
if (!brokenTasks.isEmpty()) {
String brokenBuilds = "\n\n[BUILD UNSTABLE] The following release tasks are failing!\n\n"
+ brokenTasks.stream().map(table1 -> String.format(
String brokenBuilds = "\n\n[BUILD UNSTABLE] The following release tasks are failing!\n\n" + brokenTasks
.stream()
.map(table1 -> String.format(
"***** Project / Task : <%s/%s> ***** \nTask Description <%s>\nException Stacktrace \n\n%s",
table1.projectName, table1.taskCaption,
table1.taskDescription,
table1.exceptions + "\n" + table1.exceptions.stream()
.map(Throwable::getStackTrace).flatMap(Arrays::stream)
.map(StackTraceElement::toString)
.collect(Collectors.joining("\n"))))
.collect(Collectors.joining("\n\n"));
table1.projectName, table1.taskCaption, table1.taskDescription,
table1.exceptions + "\n"
+ table1.exceptions.stream().map(Throwable::getStackTrace).flatMap(Arrays::stream)
.map(StackTraceElement::toString).collect(Collectors.joining("\n"))))
.collect(Collectors.joining("\n\n"));
log.warn(string + brokenBuilds);
}
else {
@@ -138,9 +127,8 @@ class SpringBatchBuildReportHandler implements BuildReportHandler {
List<Throwable> exceptions;
Table(String creationTime, String executionTime, String projectName,
String taskCaption, String taskDescription, String taskState,
List<Throwable> exceptions) {
Table(String creationTime, String executionTime, String projectName, String taskCaption, String taskDescription,
String taskState, List<Throwable> exceptions) {
this.creationTime = creationTime;
this.executionTime = executionTime;
this.projectName = projectName;

34
releaser-spring/src/main/java/releaser/internal/spring/SpringBatchExecutionResultHandler.java
View File

@@ -29,15 +29,13 @@ import org.springframework.context.ConfigurableApplicationContext;
class SpringBatchExecutionResultHandler implements ExecutionResultHandler {
private static final Logger log = LoggerFactory
.getLogger(SpringBatchExecutionResultHandler.class);
private static final Logger log = LoggerFactory.getLogger(SpringBatchExecutionResultHandler.class);
private final ConfigurableApplicationContext context;
private final BuildReportHandler buildReportHandler;
SpringBatchExecutionResultHandler(BuildReportHandler buildReportHandler,
ConfigurableApplicationContext context) {
SpringBatchExecutionResultHandler(BuildReportHandler buildReportHandler, ConfigurableApplicationContext context) {
this.buildReportHandler = buildReportHandler;
this.context = context;
}
@@ -53,8 +51,7 @@ class SpringBatchExecutionResultHandler implements ExecutionResultHandler {
return;
}
else if (executionResult.isUnstable()) {
log.warn(
"The release went fine, however at least one unstable post release task was found",
log.warn("The release went fine, however at least one unstable post release task was found",
executionResult.foundExceptions());
handleUnstableException();
}
@@ -77,12 +74,11 @@ class SpringBatchExecutionResultHandler implements ExecutionResultHandler {
buildStatus.createNewFile();
String text = "[BUILD UNSTABLE] The release happened successfully, but there were post release issues";
Files.write(buildStatus.toPath(), text.getBytes());
log.info(
"\n\n\n ___ _ _ ___ _ ___ _ _ _ _ ___ _____ _ ___ _ ___ \n"
+ " | _ ) | | |_ _| | | \\ | | | | \\| / __|_ _/_\\ | _ ) | | __|\n"
+ " | _ \\ |_| || || |__| |) | | |_| | .` \\__ \\ | |/ _ \\| _ \\ |__| _| \n"
+ " |___/\\___/|___|____|___/ \\___/|_|\\_|___/ |_/_/ \\_\\___/____|___|\n"
+ " ");
log.info("\n\n\n ___ _ _ ___ _ ___ _ _ _ _ ___ _____ _ ___ _ ___ \n"
+ " | _ ) | | |_ _| | | \\ | | | | \\| / __|_ _/_\\ | _ ) | | __|\n"
+ " | _ \\ |_| || || |__| |) | | |_| | .` \\__ \\ | |/ _ \\| _ \\ |__| _| \n"
+ " |___/\\___/|___|____|___/ \\___/|_|\\_|___/ |_/_/ \\_\\___/____|___|\n"
+ " ");
}
catch (IOException e) {
throw new IllegalStateException(
@@ -101,12 +97,11 @@ class SpringBatchExecutionResultHandler implements ExecutionResultHandler {
buildStatus.createNewFile();
String text = "[BUILD STABLE] All the release steps have been successfully executed!";
Files.write(buildStatus.toPath(), text.getBytes());
log.info(
"\n\n\n ___ _ _ ___ _ ___ ___ _ _ ___ ___ ___ ___ ___ ___ _ _ _ \n"
+ " | _ ) | | |_ _| | | \\ / __| | | |/ __/ __| __/ __/ __| __| | | | | \n"
+ " | _ \\ |_| || || |__| |) | \\__ \\ |_| | (_| (__| _|\\__ \\__ \\ _|| |_| | |__ \n"
+ " |___/\\___/|___|____|___/ |___/\\___/ \\___\\___|___|___/___/_| \\___/|____|\n"
+ " ");
log.info("\n\n\n ___ _ _ ___ _ ___ ___ _ _ ___ ___ ___ ___ ___ ___ _ _ _ \n"
+ " | _ ) | | |_ _| | | \\ / __| | | |/ __/ __| __/ __/ __| __| | | | | \n"
+ " | _ \\ |_| || || |__| |) | \\__ \\ |_| | (_| (__| _|\\__ \\__ \\ _|| |_| | |__ \n"
+ " |___/\\___/|___|____|___/ |___/\\___/ \\___\\___|___|___/___/_| \\___/|____|\n"
+ " ");
}
catch (IOException e) {
log.info("Failed to store the file but the build was stable");
@@ -131,8 +126,7 @@ class SpringBatchExecutionResultHandler implements ExecutionResultHandler {
+ " ");
}
catch (IOException e) {
throw new IllegalStateException(
"[BUILD FAILED] Couldn't create a file to show that the build is unstable");
throw new IllegalStateException("[BUILD FAILED] Couldn't create a file to show that the build is unstable");
}
}

179
releaser-spring/src/main/java/releaser/internal/spring/SpringBatchFlowRunner.java
View File

@@ -67,8 +67,7 @@ import org.springframework.core.task.TaskExecutor;
class SpringBatchFlowRunner implements FlowRunner, Closeable {
private static final Logger log = LoggerFactory
.getLogger(SpringBatchFlowRunner.class);
private static final Logger log = LoggerFactory.getLogger(SpringBatchFlowRunner.class);
private static final String MSG = "\nPress 'q' to quit, 's' to skip, any key to continue\n\n";
@@ -90,12 +89,10 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
private final ReleaserProperties releaserProperties;
SpringBatchFlowRunner(StepBuilderFactory stepBuilderFactory,
JobBuilderFactory jobBuilderFactory,
SpringBatchFlowRunner(StepBuilderFactory stepBuilderFactory, JobBuilderFactory jobBuilderFactory,
ProjectsToRunFactory projectsToRunFactory, JobLauncher jobLauncher,
FlowRunnerTaskExecutorSupplier flowRunnerTaskExecutorSupplier,
ConfigurableApplicationContext context, ReleaserProperties releaserProperties,
BuildReportHandler reportHandler) {
FlowRunnerTaskExecutorSupplier flowRunnerTaskExecutorSupplier, ConfigurableApplicationContext context,
ReleaserProperties releaserProperties, BuildReportHandler reportHandler) {
this.stepBuilderFactory = stepBuilderFactory;
this.jobBuilderFactory = jobBuilderFactory;
this.projectsToRunFactory = projectsToRunFactory;
@@ -103,58 +100,48 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
this.flowRunnerTaskExecutorSupplier = flowRunnerTaskExecutorSupplier;
this.stepSkipper = new ConsoleInputStepSkipper(context, reportHandler);
this.releaserProperties = releaserProperties;
this.executorService = Executors.newFixedThreadPool(
this.releaserProperties.getMetaRelease().getReleaseGroupThreadCount());
this.executorService = Executors
.newFixedThreadPool(this.releaserProperties.getMetaRelease().getReleaseGroupThreadCount());
}
@Override
public Decision beforeTask(Options options, ReleaserProperties properties,
ReleaserTask releaserTask) {
public Decision beforeTask(Options options, ReleaserProperties properties, ReleaserTask releaserTask) {
return decide(options, releaserTask);
}
private Step createStep(ReleaserTask releaserTask,
NamedArgumentsSupplier argsSupplier) {
return this.stepBuilderFactory
.get(argsSupplier.projectName + "_" + releaserTask.name())
private Step createStep(ReleaserTask releaserTask, NamedArgumentsSupplier argsSupplier) {
return this.stepBuilderFactory.get(argsSupplier.projectName + "_" + releaserTask.name())
.tasklet((contribution, chunkContext) -> {
Arguments args = argsSupplier.get();
FlowRunner.Decision decision = beforeTask(args.options,
args.properties, releaserTask);
FlowRunner.Decision decision = beforeTask(args.options, args.properties, releaserTask);
if (decision == FlowRunner.Decision.CONTINUE) {
ExecutionResult result = runTask(releaserTask, args);
contribution.getStepExecution().getExecutionContext()
.put("result", result);
List<Throwable> errors = (List<Throwable>) contribution
.getStepExecution().getExecutionContext().get("errors");
contribution.getStepExecution().getExecutionContext().put("result", result);
List<Throwable> errors = (List<Throwable>) contribution.getStepExecution().getExecutionContext()
.get("errors");
RuntimeException exception = result.foundExceptions();
errors = addExceptionToErrors(errors, exception);
String status = result.toStringResult();
ExecutionResultReport entity = buildEntity(releaserTask, args,
status, errors);
contribution.getStepExecution().getExecutionContext()
.put("entity", entity);
ExecutionResultReport entity = buildEntity(releaserTask, args, status, errors);
contribution.getStepExecution().getExecutionContext().put("entity", entity);
if (result.isFailureOrUnstable()) {
log.warn("The execution of [{}] failed [{}] / unstable [{}]",
entity.getReleaserTaskType().getSimpleName(),
result.isFailure(), result.isUnstable());
contribution.getStepExecution().getExecutionContext()
.put("errors", errors);
entity.getReleaserTaskType().getSimpleName(), result.isFailure(),
result.isUnstable());
contribution.getStepExecution().getExecutionContext().put("errors", errors);
}
}
else {
ExecutionResultReport entity = buildEntity(releaserTask, args,
"SKIPPED", Collections.emptyList());
contribution.getStepExecution().getExecutionContext()
.put("entity", entity);
ExecutionResultReport entity = buildEntity(releaserTask, args, "SKIPPED",
Collections.emptyList());
contribution.getStepExecution().getExecutionContext().put("entity", entity);
log.info("Skipping step [{}]", releaserTask.name());
}
return RepeatStatus.FINISHED;
}).listener(releaserListener(argsSupplier, releaserTask)).build();
}
private List<Throwable> addExceptionToErrors(List<Throwable> errors,
RuntimeException exception) {
private List<Throwable> addExceptionToErrors(List<Throwable> errors, RuntimeException exception) {
if (errors == null) {
errors = new LinkedList<>();
}
@@ -164,14 +151,13 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
return errors;
}
private ExecutionResultReport buildEntity(ReleaserTask releaserTask, Arguments args,
String state, List<Throwable> errors) {
private ExecutionResultReport buildEntity(ReleaserTask releaserTask, Arguments args, String state,
List<Throwable> errors) {
String projectName = args.project.getName();
String shortName = releaserTask.getClass().getSimpleName();
String description = releaserTask.description();
Class<? extends ReleaserTask> releaseType = releaserTask.getClass();
return new ExecutionResultReport(projectName, shortName, description, releaseType,
state, errors);
return new ExecutionResultReport(projectName, shortName, description, releaseType, state, errors);
}
private ExecutionResult runTask(ReleaserTask releaserTask, Arguments args) {
@@ -197,25 +183,21 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
}
}
private StepExecutionListener releaserListener(NamedArgumentsSupplier argsSupplier,
ReleaserTask releaserTask) {
private StepExecutionListener releaserListener(NamedArgumentsSupplier argsSupplier, ReleaserTask releaserTask) {
return new StepExecutionListenerSupport() {
@Override
public ExitStatus afterStep(StepExecution stepExecution) {
Arguments args = argsSupplier.get();
FlowRunner.Decision decision = afterTask(args.options, args.properties,
releaserTask);
FlowRunner.Decision decision = afterTask(args.options, args.properties, releaserTask);
if (decision == FlowRunner.Decision.ABORT) {
return ExitStatus.FAILED;
}
ExecutionResult result = (ExecutionResult) stepExecution
.getExecutionContext().get("result");
ExecutionResult result = (ExecutionResult) stepExecution.getExecutionContext().get("result");
if (result == null || result.isSuccess()) {
return stepExecution.getExitStatus();
}
else if (result.isUnstable()) {
return ExitStatus.COMPLETED
.addExitDescription(BuildUnstableException.DESCRIPTION);
return ExitStatus.COMPLETED.addExitDescription(BuildUnstableException.DESCRIPTION);
}
else if (result.isFailure()) {
return ExitStatus.FAILED;
@@ -226,8 +208,8 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
}
@Override
public ExecutionResult runReleaseTasks(Options options, ReleaserProperties properties,
ProjectsToRun projectsToRun, TasksToRun tasksToRun) {
public ExecutionResult runReleaseTasks(Options options, ReleaserProperties properties, ProjectsToRun projectsToRun,
TasksToRun tasksToRun) {
if (properties.isPostReleaseTasksOnly() && options.metaRelease) {
log.info("Only post release tasks will be executed for the meta release");
return ExecutionResult.skipped();
@@ -237,8 +219,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
if (groups.hasGroups()) {
log.info("Found the following release groups {}", releaseGroups);
}
List<StuffToRun> flows = releaseGroups.stream()
.map(group -> buildFlowForGroup(tasksToRun, group))
List<StuffToRun> flows = releaseGroups.stream().map(group -> buildFlowForGroup(tasksToRun, group))
.collect(Collectors.toCollection(LinkedList::new));
Iterator<StuffToRun> flowsIterator = flows.iterator();
if (!flowsIterator.hasNext()) {
@@ -252,16 +233,14 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
return runJob(buildJobForFlows(flowsIterator));
}
private ExecutionResult runComposites(List<StuffToRun> flows,
ProjectsToReleaseGroups groups) {
private ExecutionResult runComposites(List<StuffToRun> flows, ProjectsToReleaseGroups groups) {
if (groups.hasGroups()) {
// will run in parallel
List<ExecutionResult> results = new LinkedList<>();
for (StuffToRun flow : flows) {
log.info("Releasing group [{}]", flow.releaseGroup);
ExecutionResult executionResult = runInParallel(flow);
log.info("Group [{}] execution result is [{}]", flow.releaseGroup,
executionResult);
log.info("Group [{}] execution result is [{}]", flow.releaseGroup, executionResult);
if (executionResult.isFailure()) {
// stop running any additional flows when an release task exception
// was found
@@ -292,8 +271,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
log.info("Scheduling a build for project [{}]", s.projectName());
List<Future<ExecutionResult>> futures = new LinkedList<>();
futures.add(this.executorService.submit(() -> {
log.info("Running a composite task [{}] in parallel",
releaserTask.name());
log.info("Running a composite task [{}] in parallel", releaserTask.name());
return releaserTask.apply(Arguments.forProject(s.get()));
}));
boolean atLeastOneFailure = false;
@@ -305,8 +283,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
}
}
if (atLeastOneFailure) {
log.warn(
"At least one project failed within the group, will NOT continue with subsequent groups");
log.warn("At least one project failed within the group, will NOT continue with subsequent groups");
break;
}
}
@@ -317,8 +294,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
ExecutionResult result = ExecutionResult.success();
for (StuffToRun stuffToRun : stuffToRunList) {
for (ProjectToRun.ProjectToRunSupplier s : stuffToRun.releaseGroup.projectsToRun) {
result = result
.merge(stuffToRun.task.apply(Arguments.forProject(s.get())));
result = result.merge(stuffToRun.task.apply(Arguments.forProject(s.get())));
if (result.isFailure()) {
return result;
}
@@ -328,8 +304,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
}
private Job buildJobForFlows(Iterator<StuffToRun> flowsIterator) {
JobBuilder release = this.jobBuilderFactory
.get("release_" + System.currentTimeMillis());
JobBuilder release = this.jobBuilderFactory.get("release_" + System.currentTimeMillis());
StuffToRun stuffToRun = flowsIterator.next();
Flow first = stuffToRun.flow;
JobFlowBuilder start = release.start(first);
@@ -344,21 +319,18 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
private StuffToRun buildFlowForGroup(TasksToRun tasksToRun, ReleaseGroup group) {
FlowBuilder<Flow> flowBuilder = new FlowBuilder<>(
group.flowName() + (group.shouldRunInParallel() ? "_Parallel" : "") + "_"
+ System.currentTimeMillis());
group.flowName() + (group.shouldRunInParallel() ? "_Parallel" : "") + "_" + System.currentTimeMillis());
Iterator<ProjectToRun.ProjectToRunSupplier> iterator = group.iterator();
if (!iterator.hasNext() || tasksToRun.isEmpty()) {
return new StuffToRun(group, flowBuilder.build());
}
// only one project to run - run in sequence
final ProjectToRun.ProjectToRunSupplier project = iterator.next();
if (tasksToRun.size() == 1
&& tasksToRun.get(0) instanceof CompositeReleaserTask) {
if (tasksToRun.size() == 1 && tasksToRun.get(0) instanceof CompositeReleaserTask) {
return new StuffToRun(group, (CompositeReleaserTask) tasksToRun.get(0));
}
flowBuilder.start(toFlowOfTasks(tasksToRun,
new NamedArgumentsSupplier(project.projectName(),
() -> Arguments.forProject(project.get())),
new NamedArgumentsSupplier(project.projectName(), () -> Arguments.forProject(project.get())),
flowBuilder(project.projectName())));
if (!iterator.hasNext()) {
return new StuffToRun(group, flowBuilder.build());
@@ -370,8 +342,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
final ProjectToRun.ProjectToRunSupplier nextProject = iterator.next();
String projectName = project.projectName();
flows.add(toFlowOfTasks(tasksToRun,
new NamedArgumentsSupplier(project.projectName(),
() -> Arguments.forProject(nextProject.get())),
new NamedArgumentsSupplier(project.projectName(), () -> Arguments.forProject(nextProject.get())),
flowBuilder(projectName)));
}
return new StuffToRun(group, split.add(flows.toArray(new Flow[0])).end());
@@ -382,10 +353,9 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
}
@Override
public ExecutionResult runPostReleaseTrainTasks(Options options,
ReleaserProperties properties, String taskName, TasksToRun tasksToRun) {
ProjectsToRun projectsToRun = postReleaseTrainProjects(
new OptionsAndProperties(properties, options));
public ExecutionResult runPostReleaseTrainTasks(Options options, ReleaserProperties properties, String taskName,
TasksToRun tasksToRun) {
ProjectsToRun projectsToRun = postReleaseTrainProjects(new OptionsAndProperties(properties, options));
Flow flow = postReleaseFlow(tasksToRun, properties, projectsToRun);
String name = taskName + "_" + System.currentTimeMillis();
if (flow == null) {
@@ -400,8 +370,7 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
return this.projectsToRunFactory.postReleaseTrain(options);
}
private Flow toFlowOfTasks(TasksToRun tasksToRun, NamedArgumentsSupplier args,
FlowBuilder<Flow> flowBuilder) {
private Flow toFlowOfTasks(TasksToRun tasksToRun, NamedArgumentsSupplier args, FlowBuilder<Flow> flowBuilder) {
Iterator<? extends ReleaserTask> iterator = tasksToRun.iterator();
ReleaserTask task = iterator.next();
flowBuilder.start(createStep(task, args));
@@ -415,10 +384,9 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
try {
JobExecution execution = this.jobLauncher.run(job, new JobParameters());
if (!ExitStatus.COMPLETED.equals(execution.getExitStatus())) {
return ExecutionResult.failure(new IllegalStateException(
"Job failed to get executed successfully. Failed with exit code ["
+ execution.getExitStatus().getExitCode()
+ "] and description ["
return ExecutionResult.failure(
new IllegalStateException("Job failed to get executed successfully. Failed with exit code ["
+ execution.getExitStatus().getExitCode() + "] and description ["
+ execution.getExitStatus().getExitDescription() + "]"));
}
List<Exception> thrownExceptions = exceptionsThrownBySteps(execution);
@@ -431,8 +399,8 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
@SuppressWarnings("unchecked")
private List<Exception> exceptionsThrownBySteps(JobExecution execution) {
return execution.getStepExecutions().stream()
.map(e -> e.getExecutionContext().get("errors") != null
return execution
.getStepExecutions().stream().map(e -> e.getExecutionContext().get("errors") != null
? (List) e.getExecutionContext().get("errors") : new LinkedList())
.reduce(new LinkedList<Exception>(), (o, o2) -> {
o.addAll(o2);
@@ -440,16 +408,15 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
});
}
private Flow postReleaseFlow(TasksToRun tasksToRun, ReleaserProperties properties,
ProjectsToRun projectsToRun) {
private Flow postReleaseFlow(TasksToRun tasksToRun, ReleaserProperties properties, ProjectsToRun projectsToRun) {
Iterator<? extends ReleaserTask> iterator = tasksToRun.iterator();
if (!iterator.hasNext()) {
return null;
}
ReleaserTask task = iterator.next();
Flow flow = flow(properties, projectsToRun, task);
FlowBuilder<Flow> flowBuilder = new FlowBuilder<Flow>(
"parallelPostRelease_" + System.currentTimeMillis()).start(flow);
FlowBuilder<Flow> flowBuilder = new FlowBuilder<Flow>("parallelPostRelease_" + System.currentTimeMillis())
.start(flow);
if (!iterator.hasNext()) {
return flowBuilder.build();
}
@@ -468,11 +435,9 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
return taskExecutor;
}
private Flow flow(ReleaserProperties properties, ProjectsToRun projectsToRun,
ReleaserTask task) {
return new FlowBuilder<Flow>(task.name() + "Flow")
.start(createStep(task, new NamedArgumentsSupplier("postRelease",
() -> Arguments.forPostRelease(properties, projectsToRun))))
private Flow flow(ReleaserProperties properties, ProjectsToRun projectsToRun, ReleaserTask task) {
return new FlowBuilder<Flow>(task.name() + "Flow").start(createStep(task,
new NamedArgumentsSupplier("postRelease", () -> Arguments.forPostRelease(properties, projectsToRun))))
.build();
}
@@ -487,10 +452,9 @@ class SpringBatchFlowRunner implements FlowRunner, Closeable {
}
private void printLog(boolean interactive, ReleaserTask task) {
String taskType = task instanceof PostReleaseReleaserTask ? "Post Release Task"
: "Release Task";
log.info("\n\n\n=== {} [{}] ===\n\n{} {}\n\n", task.header(), taskType,
task.description(), interactive ? MSG : "");
String taskType = task instanceof PostReleaseReleaserTask ? "Post Release Task" : "Release Task";
log.info("\n\n\n=== {} [{}] ===\n\n{} {}\n\n", task.header(), taskType, task.description(),
interactive ? MSG : "");
}
@Override
@@ -539,8 +503,7 @@ class ConsoleInputStepSkipper {
private final BuildReportHandler reportHandler;
ConsoleInputStepSkipper(ConfigurableApplicationContext context,
BuildReportHandler reportHandler) {
ConsoleInputStepSkipper(ConfigurableApplicationContext context, BuildReportHandler reportHandler) {
this.context = context;
this.reportHandler = reportHandler;
}
@@ -600,19 +563,16 @@ class ProjectsToReleaseGroups {
}
List<ReleaseGroup> toReleaseGroup(ProjectsToRun projectsToRun) {
ReleaseGroups releaseGroups = new ReleaseGroups(
this.releaserProperties.getMetaRelease().getReleaseGroups());
return releaseGroup(releaseGroups, null, new LinkedList<>(),
projectsToRun.iterator());
ReleaseGroups releaseGroups = new ReleaseGroups(this.releaserProperties.getMetaRelease().getReleaseGroups());
return releaseGroup(releaseGroups, null, new LinkedList<>(), projectsToRun.iterator());
}
boolean hasGroups() {
return !this.releaserProperties.getMetaRelease().getReleaseGroups().isEmpty();
}
private List<ReleaseGroup> releaseGroup(ReleaseGroups releaseGroups,
ReleaseGroup currentGroup, List<ReleaseGroup> merged,
Iterator<ProjectToRun.ProjectToRunSupplier> iterator) {
private List<ReleaseGroup> releaseGroup(ReleaseGroups releaseGroups, ReleaseGroup currentGroup,
List<ReleaseGroup> merged, Iterator<ProjectToRun.ProjectToRunSupplier> iterator) {
if (iterator.hasNext()) {
// sleuth
ProjectToRun.ProjectToRunSupplier supplier = iterator.next();
@@ -678,14 +638,12 @@ class ReleaseGroup {
}
private String projectName() {
return this.projectsToRun.isEmpty() ? "EMPTY"
: this.projectsToRun.get(0).projectName();
return this.projectsToRun.isEmpty() ? "EMPTY" : this.projectsToRun.get(0).projectName();
}
@Override
public String toString() {
return "ReleaseGroup{" + "group="
+ (group.length > 0 ? Arrays.toString(group) : projectName()) + '}';
return "ReleaseGroup{" + "group=" + (group.length > 0 ? Arrays.toString(group) : projectName()) + '}';
}
}
@@ -699,8 +657,7 @@ class ReleaseGroups {
}
String[] group(String name) {
String foundGroup = this.releaseGroups.stream().filter(s -> s.contains(name))
.findFirst().orElse(null);
String foundGroup = this.releaseGroups.stream().filter(s -> s.contains(name)).findFirst().orElse(null);
if (foundGroup == null) {
return new String[0];
}

30
releaser-spring/src/main/java/releaser/internal/spring/TasksToRunFactory.java
View File

@@ -51,11 +51,9 @@ class TasksToRunFactory {
TasksToRun release(OptionsAndProperties optionsAndProperties) {
TasksToRun tasks = releaseTasks(optionsAndProperties);
tasks.forEach(t -> t.setup(optionsAndProperties.options,
optionsAndProperties.properties));
log.info("Will run the following tasks {}",
tasks.stream().map(t -> t.getClass().getSimpleName()).collect(Collectors
.toCollection((Supplier<LinkedList<String>>) LinkedList::new)));
tasks.forEach(t -> t.setup(optionsAndProperties.options, optionsAndProperties.properties));
log.info("Will run the following tasks {}", tasks.stream().map(t -> t.getClass().getSimpleName())
.collect(Collectors.toCollection((Supplier<LinkedList<String>>) LinkedList::new)));
return tasks;
}
@@ -67,8 +65,7 @@ class TasksToRunFactory {
}
if (options.metaRelease) {
if (options.dryRun) {
return new TasksToRun(
this.context.getBean(MetaReleaseDryRunCompositeTask.class));
return new TasksToRun(this.context.getBean(MetaReleaseDryRunCompositeTask.class));
}
return new TasksToRun(this.context.getBean(MetaReleaseCompositeTask.class));
}
@@ -79,8 +76,7 @@ class TasksToRunFactory {
return new TasksToRun(this.context.getBean(ReleaseCompositeTask.class));
}
// A single project release
List<ReleaserTask> tasks = new LinkedList<>(
this.context.getBeansOfType(ReleaserTask.class).values());
List<ReleaserTask> tasks = new LinkedList<>(this.context.getBeansOfType(ReleaserTask.class).values());
tasks.sort(AnnotationAwareOrderComparator.INSTANCE);
return tasksToRunForSingleProject(options, tasks);
}
@@ -95,8 +91,7 @@ class TasksToRunFactory {
return new TasksToRun(tasks);
}
private TasksToRun tasksToRunForSingleProject(Options options,
List<ReleaserTask> tasks) {
private TasksToRun tasksToRunForSingleProject(Options options, List<ReleaserTask> tasks) {
if (StringUtils.hasText(options.startFrom)) {
return startFrom(tasks, options);
}
@@ -151,8 +146,7 @@ class TasksToRunFactory {
private TasksToRun startFrom(List<ReleaserTask> tasks, Options options) {
TasksToRun tasksToRun = new TasksToRun();
for (ReleaserTask task : tasks) {
if (options.startFrom.trim().equals(task.name())
|| options.startFrom.trim().equals(task.shortName())) {
if (options.startFrom.trim().equals(task.name()) || options.startFrom.trim().equals(task.shortName())) {
tasksToRun.add(task);
}
}
@@ -165,13 +159,11 @@ class TasksToRunFactory {
for (int i = 0; i < allTasks.size(); i++) {
msg.append(i).append(") ").append(allTasks.get(i).description()).append("\n");
}
msg.append("\n").append(
"You can pick a range of options by using the hyphen - e.g. '2-4' will execute jobs [2,3,4]\n");
msg.append("You can execute all tasks starting from a job "
+ "by using a hyphen and providing only one "
msg.append("\n")
.append("You can pick a range of options by using the hyphen - e.g. '2-4' will execute jobs [2,3,4]\n");
msg.append("You can execute all tasks starting from a job " + "by using a hyphen and providing only one "
+ "number - e.g. '8-' will execute jobs [8,9,10]\n");
msg.append("You can execute given tasks by providing a "
+ "comma separated list of tasks - e.g. "
msg.append("You can execute given tasks by providing a " + "comma separated list of tasks - e.g. "
+ "'3,7,8' will execute jobs [3,7,8]\n");
msg.append("\n").append("You can press 'q' to quit\n\n");
return msg;

46
releaser-spring/src/main/java/releaser/internal/spring/VersionsToBumpFactory.java
View File

@@ -34,8 +34,7 @@ import org.springframework.util.StringUtils;
class VersionsToBumpFactory implements Closeable {
private static final Logger log = LoggerFactory
.getLogger(VersionsToBumpFactory.class);
private static final Logger log = LoggerFactory.getLogger(VersionsToBumpFactory.class);
private static final Map<File, ProjectsFromBom> CACHE = new ConcurrentHashMap<>();
@@ -51,10 +50,9 @@ class VersionsToBumpFactory implements Closeable {
ProjectsFromBom withProject(File project) {
return CACHE.computeIfAbsent(project, file -> {
log.info("Fetch from git [{}], meta release [{}], project [{}]",
this.properties.getGit().isFetchVersionsFromGit(),
this.properties.getMetaRelease().isEnabled(), project);
if (this.properties.getGit().isFetchVersionsFromGit()
&& !this.properties.getMetaRelease().isEnabled()) {
this.properties.getGit().isFetchVersionsFromGit(), this.properties.getMetaRelease().isEnabled(),
project);
if (this.properties.getGit().isFetchVersionsFromGit() && !this.properties.getMetaRelease().isEnabled()) {
return fetchVersionsFromGitForSingleProject(project);
}
return fetchVersionsFromFixedProjects(project);
@@ -65,14 +63,12 @@ class VersionsToBumpFactory implements Closeable {
ProjectVersion originalVersion = new ProjectVersion(project);
Projects fixedVersions = this.releaser.fixedVersions();
log.info("Got the following fixed versions [{}]", fixedVersions);
String fixedVersionForProject = fixedVersions
.containsProject(originalVersion.projectName)
? fixedVersions.forName(originalVersion.projectName).version : "";
log.info("Found fixed version for this project [{}] is [{}]",
originalVersion.projectName, fixedVersionForProject);
String fixedVersionForProject = fixedVersions.containsProject(originalVersion.projectName)
? fixedVersions.forName(originalVersion.projectName).version : "";
log.info("Found fixed version for this project [{}] is [{}]", originalVersion.projectName,
fixedVersionForProject);
ProjectVersion versionFromBom = StringUtils.hasText(fixedVersionForProject)
? new ProjectVersion(originalVersion.projectName, fixedVersionForProject)
: new ProjectVersion(project);
? new ProjectVersion(originalVersion.projectName, fixedVersionForProject) : new ProjectVersion(project);
log.info("Version from bom [{}]", versionFromBom);
fixedVersions.add(versionFromBom);
printSettingVersionFromFixedVersions(fixedVersions);
@@ -82,43 +78,35 @@ class VersionsToBumpFactory implements Closeable {
private ProjectsFromBom fetchVersionsFromGitForSingleProject(File project) {
printVersionRetrieval();
Projects projectsToUpdate = this.releaser.retrieveVersionsFromBom();
ProjectVersion versionFromBom = assertNoSnapshotsForANonSnapshotProject(project,
projectsToUpdate);
ProjectVersion versionFromBom = assertNoSnapshotsForANonSnapshotProject(project, projectsToUpdate);
return cachedProjectsFromBom(versionFromBom, projectsToUpdate);
}
private ProjectsFromBom cachedProjectsFromBom(ProjectVersion versionFromBom,
Projects projectsToUpdate) {
private ProjectsFromBom cachedProjectsFromBom(ProjectVersion versionFromBom, Projects projectsToUpdate) {
return new ProjectsFromBom(projectsToUpdate, versionFromBom);
}
ProjectVersion assertNoSnapshotsForANonSnapshotProject(File project,
Projects projectsToUpdate) {
ProjectVersion assertNoSnapshotsForANonSnapshotProject(File project, Projects projectsToUpdate) {
ProjectVersion versionFromBom;
versionFromBom = projectsToUpdate.forFile(project);
assertNoSnapshotsForANonSnapshotProject(projectsToUpdate, versionFromBom);
return versionFromBom;
}
private void assertNoSnapshotsForANonSnapshotProject(Projects projects,
ProjectVersion versionFromBom) {
private void assertNoSnapshotsForANonSnapshotProject(Projects projects, ProjectVersion versionFromBom) {
if (!versionFromBom.isSnapshot() && projects.containsSnapshots()) {
throw new IllegalStateException("You are trying to release a non snapshot "
+ "version [" + versionFromBom + "] of the project ["
+ versionFromBom.projectName + "] but "
throw new IllegalStateException("You are trying to release a non snapshot " + "version [" + versionFromBom
+ "] of the project [" + versionFromBom.projectName + "] but "
+ "there is at least one SNAPSHOT library version in the Spring Cloud Release project");
}
}
private void printVersionRetrieval() {
log.info("\n\n\n=== RETRIEVING VERSIONS ===\n\nWill clone the BOM project"
+ " to retrieve all versions");
log.info("\n\n\n=== RETRIEVING VERSIONS ===\n\nWill clone the BOM project" + " to retrieve all versions");
}
private void printSettingVersionFromFixedVersions(Projects projectsToUpdate) {
log.info(
"\n\n\n=== RETRIEVED VERSIONS ===\n\nWill use the fixed versions"
+ " of projects\n\n{}",
log.info("\n\n\n=== RETRIEVED VERSIONS ===\n\nWill use the fixed versions" + " of projects\n\n{}",
projectsToUpdate.stream().map(p -> p.projectName + " => " + p.version)
.collect(Collectors.joining("\n")));
}

3
releaser-spring/src/main/java/releaser/internal/tasks/ProjectPostReleaseReleaserTask.java
View File

@@ -20,7 +20,6 @@ package releaser.internal.tasks;
* Marker interface for a post release task for a single project. Example: update the
* GitHub milestone for the project.
*/
public interface ProjectPostReleaseReleaserTask
extends SingleProjectReleaserTask, PostReleaseReleaserTask {
public interface ProjectPostReleaseReleaserTask extends SingleProjectReleaserTask, PostReleaseReleaserTask {
}

3
releaser-spring/src/main/java/releaser/internal/tasks/ReleaserTask.java
View File

@@ -92,7 +92,6 @@ public interface ReleaserTask extends Ordered, Function<Arguments, ExecutionResu
* shouldn't be stopped (which means that the build is unstable)
* @throws RuntimeException - when the task failed for any other reason
*/
ExecutionResult runTask(Arguments args)
throws BuildUnstableException, RuntimeException;
ExecutionResult runTask(Arguments args) throws BuildUnstableException, RuntimeException;
}

6
releaser-spring/src/main/java/releaser/internal/tasks/composite/CompositeTasksConfiguration.java
View File

@@ -41,8 +41,7 @@ class CompositeTasksConfiguration {
@Bean
@ConditionalOnMissingBean
MetaReleaseDryRunCompositeTask metaReleaseDryRunCompositeTask(
ApplicationContext context) {
MetaReleaseDryRunCompositeTask metaReleaseDryRunCompositeTask(ApplicationContext context) {
return new MetaReleaseDryRunCompositeTask(context);
}
@@ -60,8 +59,7 @@ class CompositeTasksConfiguration {
@Bean
@ConditionalOnMissingBean
TrainPostReleaseCompositeTask trainPostReleaseCompositeTask(
ApplicationContext context) {
TrainPostReleaseCompositeTask trainPostReleaseCompositeTask(ApplicationContext context) {
return new TrainPostReleaseCompositeTask(context);
}

11
releaser-spring/src/main/java/releaser/internal/tasks/composite/DryRunCompositeTask.java
View File

@@ -83,13 +83,10 @@ public class DryRunCompositeTask implements CompositeReleaserTask {
.getBeansOfType(DryRunReleaseReleaserTask.class);
List<DryRunReleaseReleaserTask> values = new LinkedList<>(dryRunTasks.values());
values.sort(AnnotationAwareOrderComparator.INSTANCE);
log.info("For project [{}], found the following dry run tasks {}",
args.project.getName(),
values.stream().map(r -> r.getClass().getSimpleName())
.collect(Collectors.toCollection(LinkedList::new)));
return flowRunner().runReleaseTasks(args.options, args.properties,
new ProjectsToRun(new ProjectToRun.ProjectToRunSupplier(
args.originalVersion.projectName, () -> args.projectToRun)),
log.info("For project [{}], found the following dry run tasks {}", args.project.getName(), values.stream()
.map(r -> r.getClass().getSimpleName()).collect(Collectors.toCollection(LinkedList::new)));
return flowRunner().runReleaseTasks(args.options, args.properties, new ProjectsToRun(
new ProjectToRun.ProjectToRunSupplier(args.originalVersion.projectName, () -> args.projectToRun)),
new TasksToRun(values));
}

3
releaser-spring/src/main/java/releaser/internal/tasks/composite/MetaReleaseCompositeTask.java
View File

@@ -36,8 +36,7 @@ public class MetaReleaseCompositeTask implements CompositeReleaserTask {
*/
public static final int ORDER = -80;
private static final Logger log = LoggerFactory
.getLogger(MetaReleaseCompositeTask.class);
private static final Logger log = LoggerFactory.getLogger(MetaReleaseCompositeTask.class);
private final ApplicationContext context;

3
releaser-spring/src/main/java/releaser/internal/tasks/composite/MetaReleaseDryRunCompositeTask.java
View File

@@ -36,8 +36,7 @@ public class MetaReleaseDryRunCompositeTask implements CompositeReleaserTask {
*/
public static final int ORDER = -70;
private static final Logger log = LoggerFactory
.getLogger(MetaReleaseDryRunCompositeTask.class);
private static final Logger log = LoggerFactory.getLogger(MetaReleaseDryRunCompositeTask.class);
private final ApplicationContext context;

17
releaser-spring/src/main/java/releaser/internal/tasks/composite/ReleaseCompositeTask.java
View File

@@ -82,23 +82,18 @@ public class ReleaseCompositeTask implements CompositeReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
Map<String, ReleaseReleaserTask> releaseTasks = this.context
.getBeansOfType(ReleaseReleaserTask.class);
Map<String, ReleaseReleaserTask> releaseTasks = this.context.getBeansOfType(ReleaseReleaserTask.class);
Map<String, ProjectPostReleaseReleaserTask> projectPostReleaseTasks = this.context
.getBeansOfType(ProjectPostReleaseReleaserTask.class);
Collection<ReleaserTask> allReleaseTasks = new LinkedList<>(
releaseTasks.values());
Collection<ReleaserTask> allReleaseTasks = new LinkedList<>(releaseTasks.values());
allReleaseTasks.addAll(projectPostReleaseTasks.values());
List<ReleaserTask> values = new LinkedList<>(allReleaseTasks);
values.sort(AnnotationAwareOrderComparator.INSTANCE);
log.info(
"For project [{}], found the following release and project post release tasks {}",
args.project.getName(),
values.stream().map(r -> r.getClass().getSimpleName())
log.info("For project [{}], found the following release and project post release tasks {}",
args.project.getName(), values.stream().map(r -> r.getClass().getSimpleName())
.collect(Collectors.toCollection(LinkedList::new)));
return flowRunner().runReleaseTasks(args.options, args.properties,
new ProjectsToRun(new ProjectToRun.ProjectToRunSupplier(
args.originalVersion.projectName, () -> args.projectToRun)),
return flowRunner().runReleaseTasks(args.options, args.properties, new ProjectsToRun(
new ProjectToRun.ProjectToRunSupplier(args.originalVersion.projectName, () -> args.projectToRun)),
new TasksToRun(values));
}

3
releaser-spring/src/main/java/releaser/internal/tasks/composite/ReleaseVerboseCompositeTask.java
View File

@@ -33,8 +33,7 @@ public class ReleaseVerboseCompositeTask implements CompositeReleaserTask {
*/
public static final int ORDER = -90;
private static final Logger log = LoggerFactory
.getLogger(ReleaseVerboseCompositeTask.class);
private static final Logger log = LoggerFactory.getLogger(ReleaseVerboseCompositeTask.class);
private final ApplicationContext context;

10
releaser-spring/src/main/java/releaser/internal/tasks/composite/TrainPostReleaseCompositeTask.java
View File

@@ -46,8 +46,7 @@ public class TrainPostReleaseCompositeTask implements CompositeReleaserTask {
*/
public static final int ORDER = -50;
private static final Logger log = LoggerFactory
.getLogger(TrainPostReleaseCompositeTask.class);
private static final Logger log = LoggerFactory.getLogger(TrainPostReleaseCompositeTask.class);
private final ApplicationContext context;
@@ -81,12 +80,11 @@ public class TrainPostReleaseCompositeTask implements CompositeReleaserTask {
public ExecutionResult runTask(Arguments args) {
Map<String, TrainPostReleaseReleaserTask> trainPostReleaseReleaserTasks = this.context
.getBeansOfType(TrainPostReleaseReleaserTask.class);
List<ReleaserTask> values = new LinkedList<>(
trainPostReleaseReleaserTasks.values());
List<ReleaserTask> values = new LinkedList<>(trainPostReleaseReleaserTasks.values());
values.sort(AnnotationAwareOrderComparator.INSTANCE);
log.info("Found the following post release tasks {}", values);
return flowRunner().runPostReleaseTrainTasks(args.options, args.properties,
this.name(), new TasksToRun(values));
return flowRunner().runPostReleaseTrainTasks(args.options, args.properties, this.name(),
new TasksToRun(values));
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CloseMilestonesProjectPostReleaseTask.java
View File

@@ -21,8 +21,7 @@ import releaser.internal.spring.Arguments;
import releaser.internal.tasks.ProjectPostReleaseReleaserTask;
import releaser.internal.tech.ExecutionResult;
public class CloseMilestonesProjectPostReleaseTask
implements ProjectPostReleaseReleaserTask {
public class CloseMilestonesProjectPostReleaseTask implements ProjectPostReleaseReleaserTask {
/**
* Order of this task. The higher value, the lower order.

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/CreateTemplatesTrainPostReleaseTask.java
View File

@@ -59,8 +59,7 @@ public class CreateTemplatesTrainPostReleaseTask implements TrainPostReleaseRele
return this.releaser.createEmail(args.versionFromBom, args.projects)
.merge(this.releaser.createBlog(args.versionFromBom, args.projects))
.merge(this.releaser.createTweet(args.versionFromBom, args.projects))
.merge(this.releaser.createReleaseNotes(args.versionFromBom,
args.projects));
.merge(this.releaser.createReleaseNotes(args.versionFromBom, args.projects));
}
@Override

24
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/PostReleaseTasksConfiguration.java
View File

@@ -26,8 +26,7 @@ import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnDefaultFlowEnabled
@ConditionalOnProperty(value = "releaser.skip-post-release-tasks", havingValue = "false",
matchIfMissing = true)
@ConditionalOnProperty(value = "releaser.skip-post-release-tasks", havingValue = "false", matchIfMissing = true)
class PostReleaseTasksConfiguration {
@Bean
@@ -40,24 +39,21 @@ class PostReleaseTasksConfiguration {
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.template.enabled")
CreateTemplatesTrainPostReleaseTask createTemplatesTrainPostReleaseTask(
Releaser releaser) {
CreateTemplatesTrainPostReleaseTask createTemplatesTrainPostReleaseTask(Releaser releaser) {
return new CreateTemplatesTrainPostReleaseTask(releaser);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.git.run-updated-samples")
RunUpdatedSamplesTrainPostReleaseTask runUpdatedSamplesTrainPostReleaseTask(
Releaser releaser) {
RunUpdatedSamplesTrainPostReleaseTask runUpdatedSamplesTrainPostReleaseTask(Releaser releaser) {
return new RunUpdatedSamplesTrainPostReleaseTask(releaser);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.git.update-all-test-samples")
UpdateAllTestSamplesTrainPostReleaseTask updateAllTestSamplesTrainPostReleaseTask(
Releaser releaser) {
UpdateAllTestSamplesTrainPostReleaseTask updateAllTestSamplesTrainPostReleaseTask(Releaser releaser) {
return new UpdateAllTestSamplesTrainPostReleaseTask(releaser);
}
@@ -71,32 +67,28 @@ class PostReleaseTasksConfiguration {
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.git.update-release-train-docs")
UpdateReleaseTrainDocsTrainPostReleaseTask updateReleaseTrainDocsTrainPostReleaseTask(
Releaser releaser) {
UpdateReleaseTrainDocsTrainPostReleaseTask updateReleaseTrainDocsTrainPostReleaseTask(Releaser releaser) {
return new UpdateReleaseTrainDocsTrainPostReleaseTask(releaser);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.git.update-release-train-wiki")
UpdateReleaseTrainWikiTrainPostReleaseTask updateReleaseTrainWikiTrainPostReleaseTask(
Releaser releaser) {
UpdateReleaseTrainWikiTrainPostReleaseTask updateReleaseTrainWikiTrainPostReleaseTask(Releaser releaser) {
return new UpdateReleaseTrainWikiTrainPostReleaseTask(releaser);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.sagan.update-sagan")
UpdateSaganProjectPostReleaseTask updateSaganProjectPostReleaseTask(
Releaser releaser) {
UpdateSaganProjectPostReleaseTask updateSaganProjectPostReleaseTask(Releaser releaser) {
return new UpdateSaganProjectPostReleaseTask(releaser);
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty("releaser.sagan.update-start-spring-io")
UpdateStartSpringIoTrainPostReleaseTask updateStartSpringIoTrainPostReleaseTask(
Releaser releaser) {
UpdateStartSpringIoTrainPostReleaseTask updateStartSpringIoTrainPostReleaseTask(Releaser releaser) {
return new UpdateStartSpringIoTrainPostReleaseTask(releaser);
}

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/RunUpdatedSamplesTrainPostReleaseTask.java
View File

@@ -21,8 +21,7 @@ import releaser.internal.spring.Arguments;
import releaser.internal.tasks.TrainPostReleaseReleaserTask;
import releaser.internal.tech.ExecutionResult;
public class RunUpdatedSamplesTrainPostReleaseTask
implements TrainPostReleaseReleaserTask {
public class RunUpdatedSamplesTrainPostReleaseTask implements TrainPostReleaseReleaserTask {
/**
* Order of this task. The higher value, the lower order.

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/UpdateAllTestSamplesTrainPostReleaseTask.java
View File

@@ -21,8 +21,7 @@ import releaser.internal.spring.Arguments;
import releaser.internal.tasks.TrainPostReleaseReleaserTask;
import releaser.internal.tech.ExecutionResult;
public class UpdateAllTestSamplesTrainPostReleaseTask
implements TrainPostReleaseReleaserTask {
public class UpdateAllTestSamplesTrainPostReleaseTask implements TrainPostReleaseReleaserTask {
/**
* Order of this task. The higher value, the lower order.

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/UpdateGuidesTrainPostReleaseTask.java
View File

@@ -56,8 +56,7 @@ public class UpdateGuidesTrainPostReleaseTask implements TrainPostReleaseRelease
@Override
public ExecutionResult runTask(Arguments args) {
return this.releaser.updateSpringGuides(args.versionFromBom, args.projects,
args.processedProjects);
return this.releaser.updateSpringGuides(args.versionFromBom, args.projects, args.processedProjects);
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/UpdateReleaseTrainDocsTrainPostReleaseTask.java
View File

@@ -21,8 +21,7 @@ import releaser.internal.spring.Arguments;
import releaser.internal.tasks.TrainPostReleaseReleaserTask;
import releaser.internal.tech.ExecutionResult;
public class UpdateReleaseTrainDocsTrainPostReleaseTask
implements TrainPostReleaseReleaserTask {
public class UpdateReleaseTrainDocsTrainPostReleaseTask implements TrainPostReleaseReleaserTask {
/**
* Order of this task. The higher value, the lower order.

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/UpdateReleaseTrainWikiTrainPostReleaseTask.java
View File

@@ -21,8 +21,7 @@ import releaser.internal.spring.Arguments;
import releaser.internal.tasks.TrainPostReleaseReleaserTask;
import releaser.internal.tech.ExecutionResult;
public class UpdateReleaseTrainWikiTrainPostReleaseTask
implements TrainPostReleaseReleaserTask {
public class UpdateReleaseTrainWikiTrainPostReleaseTask implements TrainPostReleaseReleaserTask {
/**
* Order of this task. The higher value, the lower order.

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/UpdateSaganProjectPostReleaseTask.java
View File

@@ -56,8 +56,7 @@ public class UpdateSaganProjectPostReleaseTask implements ProjectPostReleaseRele
@Override
public ExecutionResult runTask(Arguments args) {
return this.releaser.updateSagan(args.project, args.versionFromBom,
args.projects);
return this.releaser.updateSagan(args.project, args.versionFromBom, args.projects);
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/postrelease/UpdateStartSpringIoTrainPostReleaseTask.java
View File

@@ -21,8 +21,7 @@ import releaser.internal.spring.Arguments;
import releaser.internal.tasks.TrainPostReleaseReleaserTask;
import releaser.internal.tech.ExecutionResult;
public class UpdateStartSpringIoTrainPostReleaseTask
implements TrainPostReleaseReleaserTask {
public class UpdateStartSpringIoTrainPostReleaseTask implements TrainPostReleaseReleaserTask {
/**
* Order of this task. The higher value, the lower order.

6
releaser-spring/src/main/java/releaser/internal/tasks/release/BuildProjectReleaseTask.java
View File

@@ -25,8 +25,7 @@ import releaser.internal.tech.ExecutionResult;
public class BuildProjectReleaseTask implements DryRunReleaseReleaserTask {
private static final Logger log = LoggerFactory
.getLogger(BuildProjectReleaseTask.class);
private static final Logger log = LoggerFactory.getLogger(BuildProjectReleaseTask.class);
/**
* Order of this task. The higher value, the lower order.
@@ -62,8 +61,7 @@ public class BuildProjectReleaseTask implements DryRunReleaseReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
log.info("Arguments for this release task: " + args);
return this.releaser.buildProject(args.properties, args.originalVersion,
args.versionFromBom);
return this.releaser.buildProject(args.properties, args.originalVersion, args.versionFromBom);
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/release/BumpBackToSnapshotReleaseTask.java
View File

@@ -56,8 +56,7 @@ public class BumpBackToSnapshotReleaseTask implements ReleaseReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
return this.releaser.rollbackReleaseVersion(args.project, args.projects,
args.versionFromBom);
return this.releaser.rollbackReleaseVersion(args.project, args.projects, args.versionFromBom);
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/release/DeployArtifactsReleaseTask.java
View File

@@ -56,8 +56,7 @@ public class DeployArtifactsReleaseTask implements ReleaseReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
return this.releaser.deploy(args.properties, args.originalVersion,
args.versionFromBom);
return this.releaser.deploy(args.properties, args.originalVersion, args.versionFromBom);
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/release/PublishDocsReleaseTask.java
View File

@@ -56,8 +56,7 @@ public class PublishDocsReleaseTask implements ReleaseReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
return this.releaser.publishDocs(args.properties, args.originalVersion,
args.versionFromBom);
return this.releaser.publishDocs(args.properties, args.originalVersion, args.versionFromBom);
}
@Override

3
releaser-spring/src/main/java/releaser/internal/tasks/release/UpdatingPomsReleaseTask.java
View File

@@ -56,8 +56,7 @@ public class UpdatingPomsReleaseTask implements DryRunReleaseReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
return this.releaser.updateProjectFromBom(args.project, args.projects,
args.versionFromBom);
return this.releaser.updateProjectFromBom(args.project, args.projects, args.versionFromBom);
}
@Override

6
releaser-spring/src/test/java/releaser/internal/buildsystem/TestUtils.java
View File

@@ -31,15 +31,13 @@ public final class TestUtils {
prepareLocalRepo("target/test-classes/projects/", "spring-cloud");
prepareLocalRepo("target/test-classes/projects/", "spring-cloud-wiki");
prepareLocalRepo("target/test-classes/projects/", "spring-cloud-release");
prepareLocalRepo("target/test-classes/projects/",
"spring-cloud-release-with-snapshot");
prepareLocalRepo("target/test-classes/projects/", "spring-cloud-release-with-snapshot");
prepareLocalRepo("target/test-classes/projects/", "spring-cloud-consul");
prepareLocalRepo("target/test-classes/projects/", "spring-cloud-build");
prepareLocalRepo("target/test-classes/projects/", "spring-cloud-static-angel");
}
private static void prepareLocalRepo(String buildDir, String repoPath)
throws IOException {
private static void prepareLocalRepo(String buildDir, String repoPath) throws IOException {
File dotGit = new File(buildDir + repoPath + "/.git");
File git = new File(buildDir + repoPath + "/git");
if (git.exists()) {

8
releaser-spring/src/test/java/releaser/internal/docs/TestDocumentationUpdater.java
View File

@@ -25,11 +25,9 @@ import releaser.internal.git.ProjectGitHandler;
*/
public class TestDocumentationUpdater extends DocumentationUpdater {
public TestDocumentationUpdater(ReleaserProperties properties,
CustomProjectDocumentationUpdater updater, ProjectGitHandler handler,
TestReleaseContentsUpdater testRelease) {
super(new ProjectDocumentationUpdater(properties, handler,
Collections.singletonList(updater)), testRelease);
public TestDocumentationUpdater(ReleaserProperties properties, CustomProjectDocumentationUpdater updater,
ProjectGitHandler handler, TestReleaseContentsUpdater testRelease) {
super(new ProjectDocumentationUpdater(properties, handler, Collections.singletonList(updater)), testRelease);
}
}

4
releaser-spring/src/test/java/releaser/internal/docs/TestReleaseContentsUpdater.java
View File

@@ -25,8 +25,8 @@ import releaser.internal.template.TemplateGenerator;
*/
public class TestReleaseContentsUpdater extends ReleaseTrainContentsUpdater {
public TestReleaseContentsUpdater(ReleaserProperties properties,
ProjectGitHandler handler, TemplateGenerator templateGenerator) {
public TestReleaseContentsUpdater(ReleaserProperties properties, ProjectGitHandler handler,
TemplateGenerator templateGenerator) {
super(properties, handler, templateGenerator);
}

3
releaser-spring/src/test/java/releaser/internal/git/GitTestUtils.java
View File

@@ -53,8 +53,7 @@ public final class GitTestUtils {
return new GitRepo.JGitFactory().open(project);
}
public static File clonedProject(File baseDir, File projectToClone)
throws IOException {
public static File clonedProject(File baseDir, File projectToClone) throws IOException {
GitRepo projectRepo = new GitRepo(baseDir);
return projectRepo.cloneProject(new URIish(projectToClone.toURI().toURL()));
}

6
releaser-spring/src/test/java/releaser/internal/spring/ProjectsToReleaseGroupsTests.java
View File

@@ -33,8 +33,7 @@ class ProjectsToReleaseGroupsTests {
properties.getMetaRelease().setReleaseGroups(Arrays.asList("c,d", "e,f,g"));
ProjectsToRun projectsToRun = projectsToRun();
List<ReleaseGroup> groups = new ProjectsToReleaseGroups(properties)
.toReleaseGroup(projectsToRun);
List<ReleaseGroup> groups = new ProjectsToReleaseGroups(properties).toReleaseGroup(projectsToRun);
BDDAssertions.then(groups).hasSize(5);
BDDAssertions.then(projectNames(0, groups)).containsExactly("a");
@@ -45,8 +44,7 @@ class ProjectsToReleaseGroupsTests {
}
private List<String> projectNames(int index, List<ReleaseGroup> groups) {
return groups.get(index).projectsToRun.stream()
.map(ProjectToRun.ProjectToRunSupplier::projectName)
return groups.get(index).projectsToRun.stream().map(ProjectToRun.ProjectToRunSupplier::projectName)
.collect(Collectors.toCollection(LinkedList::new));
}

7
releaser-spring/src/test/java/releaser/internal/spring/ReleaserPropertiesUpdaterTests.java
View File

@@ -32,8 +32,8 @@ public class ReleaserPropertiesUpdaterTests {
File relaserUpdater;
public ReleaserPropertiesUpdaterTests() throws URISyntaxException {
this.relaserUpdater = new File(ReleaserPropertiesUpdaterTests.class
.getResource("/projects/releaser-updater/").toURI());
this.relaserUpdater = new File(
ReleaserPropertiesUpdaterTests.class.getResource("/projects/releaser-updater/").toURI());
}
@Test
@@ -41,8 +41,7 @@ public class ReleaserPropertiesUpdaterTests {
ReleaserProperties original = originalReleaserProperties();
ReleaserPropertiesUpdater updater = new ReleaserPropertiesUpdater();
ReleaserProperties props = updater.updateProperties(original,
this.relaserUpdater);
ReleaserProperties props = updater.updateProperties(original, this.relaserUpdater);
BDDAssertions.then(props.getMaven().getBuildCommand()).isEqualTo("maven_build");
BDDAssertions.then(props.getGradle().getBuildCommand()).isEqualTo("gradle_build");

39
releaser-spring/src/test/java/releaser/internal/spring/SpringBatchFlowRunnerTests.java
View File

@@ -48,52 +48,42 @@ class SpringBatchFlowRunnerTests {
ReleaserProperties releaserProperties = new ReleaserProperties();
@Test
void should_not_fail_the_release_when_project_post_release_task_fails(
@Autowired SpringBatchFlowRunner runner) {
void should_not_fail_the_release_when_project_post_release_task_fails(@Autowired SpringBatchFlowRunner runner) {
Options options = new OptionsBuilder().interactive(false).options();
ProjectsToRun projectsToRun = projectsToRun(options, releaserProperties);
TasksToRun tasks = new TasksToRun(new MyProjectPostReleaseTask());
ExecutionResult executionResult = runner.runReleaseTasks(options,
releaserProperties, projectsToRun, tasks);
ExecutionResult executionResult = runner.runReleaseTasks(options, releaserProperties, projectsToRun, tasks);
BDDAssertions.then(executionResult.isUnstable()).isTrue();
}
@Test
void should_execute_post_train_tasks_when_such_property_is_set(
@Autowired SpringBatchFlowRunner runner,
void should_execute_post_train_tasks_when_such_property_is_set(@Autowired SpringBatchFlowRunner runner,
@Autowired ProjectsToRunFactory factory) {
Options options = new OptionsBuilder().interactive(false).metaRelease(true)
.options();
Options options = new OptionsBuilder().interactive(false).metaRelease(true).options();
releaserProperties.setPostReleaseTasksOnly(true);
releaserProperties.getMetaRelease().setReleaseTrainProjectName("foo");
ProjectsToRun projectsToRun = projectsToRun(options, releaserProperties);
BDDMockito.given(factory.postReleaseTrain(BDDMockito.any()))
.willReturn(projectsToRun);
BDDMockito.given(factory.postReleaseTrain(BDDMockito.any())).willReturn(projectsToRun);
TasksToRun tasks = new TasksToRun(new MyPostTrainReleaseTask());
ExecutionResult executionResult = runner.runReleaseTasks(options,
releaserProperties, projectsToRun, tasks);
ExecutionResult executionResult = runner.runReleaseTasks(options, releaserProperties, projectsToRun, tasks);
BDDAssertions.then(executionResult.isSkipped()).isTrue();
executionResult = runner.runPostReleaseTrainTasks(options, releaserProperties,
"post-release", tasks);
executionResult = runner.runPostReleaseTrainTasks(options, releaserProperties, "post-release", tasks);
BDDAssertions.then(executionResult.isSuccess()).isTrue();
}
private ProjectsToRun projectsToRun(Options options,
ReleaserProperties releaserProperties) {
return new ProjectsToRun(new ProjectToRun.ProjectToRunSupplier("test",
() -> projectToRun(options, releaserProperties)));
private ProjectsToRun projectsToRun(Options options, ReleaserProperties releaserProperties) {
return new ProjectsToRun(
new ProjectToRun.ProjectToRunSupplier("test", () -> projectToRun(options, releaserProperties)));
}
private ProjectToRun projectToRun(Options options,
ReleaserProperties releaserProperties) {
return new ProjectToRun(new File("."),
new ProjectsFromBom(new Projects(), new ProjectVersion("foo", "0.0.1")),
private ProjectToRun projectToRun(Options options, ReleaserProperties releaserProperties) {
return new ProjectToRun(new File("."), new ProjectsFromBom(new Projects(), new ProjectVersion("foo", "0.0.1")),
new ProjectVersion("foo", "0.0.1"), releaserProperties, options);
}
@@ -139,9 +129,8 @@ class MyProjectPostReleaseTask implements ProjectPostReleaseReleaserTask {
@Override
public ExecutionResult runTask(Arguments args) {
return ExecutionResult.unstable(
HttpServerErrorException.create(HttpStatus.INTERNAL_SERVER_ERROR, "foo",
new HttpHeaders(), "".getBytes(), Charset.defaultCharset()));
return ExecutionResult.unstable(HttpServerErrorException.create(HttpStatus.INTERNAL_SERVER_ERROR, "foo",
new HttpHeaders(), "".getBytes(), Charset.defaultCharset()));
}
@Override