io.takari.maven.builder.smart.ReactorBuildQueue Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of takari-smart-builder Show documentation
There is a newer version: 1.0.2
package io.takari.maven.builder.smart;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.maven.execution.ProjectDependencyGraph;
import org.apache.maven.project.MavenProject;

/**
 * Reactor build queue manages reactor modules that are waiting for their upstream dependencies
 * build to finish.
 */
class ReactorBuildQueue {

  private final ProjectDependencyGraph dependencyGraph;

  private final Set rootProjects;

  private final Collection projects;

  /**
   * Projects waiting for other projects to finish
   */
  private final Set blockedProjects = new HashSet();

  private final Set finishedProjects = new HashSet();

  public ReactorBuildQueue(ProjectDependencyGraph dependencyGraph) {
    this.dependencyGraph = dependencyGraph;

    final List projects = dependencyGraph.getSortedProjects();
    final Set rootProjects = new HashSet();

    for (MavenProject project : projects) {
      if (dependencyGraph.getUpstreamProjects(project, false).isEmpty()) {
        rootProjects.add(project);
      } else {
        blockedProjects.add(project);
      }
    }

    this.rootProjects = Collections.unmodifiableSet(rootProjects);
    this.projects = Collections.unmodifiableList(projects);
  }

  /**
   * Marks specified project as finished building. Returns, possible empty, set of project's
   * downstream dependencies that become ready to build.
   */
  public Set onProjectFinish(MavenProject project) {
    finishedProjects.add(project);
    Set downstreamProjects = new HashSet();
    for (MavenProject successor : getDownstreamProjects(project)) {
      if (blockedProjects.contains(successor) && isProjectReady(successor)) {
        blockedProjects.remove(successor);
        downstreamProjects.add(successor);
      }
    }
    return downstreamProjects;
  }

  public List getDownstreamProjects(MavenProject project) {
    return dependencyGraph.getDownstreamProjects(project, false);
  }

  private boolean isProjectReady(MavenProject project) {
    for (MavenProject upstream : dependencyGraph.getUpstreamProjects(project, false)) {
      if (!finishedProjects.contains(upstream)) {
        return false;
      }
    }
    return true;
  }

  /**
   * Returns {@code true} when no more projects are left to schedule.
   */
  public boolean isEmpty() {
    return blockedProjects.isEmpty();
  }

  /**
   * Returns reactor build root projects, that is, projects that do not have upstream dependencies.
   */
  public Set getRootProjects() {
    return rootProjects;
  }

  public int getBlockedCount() {
    return blockedProjects.size();
  }

  public int getFinishedCount() {
    return finishedProjects.size();
  }

  public int getReadyCount() {
    return projects.size() - blockedProjects.size() - finishedProjects.size();
  }

  public Set getReadyProjects() {
    Set projects = new HashSet<>(this.projects);
    projects.removeAll(blockedProjects);
    projects.removeAll(finishedProjects);
    return projects;
  }

}