MatrixProject.java

/*
 * The MIT License
 *
 * Copyright (c) 2004-2011, Sun Microsystems, Inc., Kohsuke Kawaguchi,
 * Jorg Heymans, Red Hat, Inc., id:cactusman
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
package hudson.matrix;

import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import hudson.CopyOnWrite;
import hudson.Extension;
import hudson.Util;
import hudson.XmlFile;
import hudson.matrix.MatrixBuild.MatrixBuildExecution;
import hudson.model.AbstractProject;
import hudson.model.Action;
import hudson.model.BuildableItemWithBuildWrappers;
import hudson.model.DependencyGraph;
import hudson.model.Descriptor;
import hudson.model.Descriptor.FormException;
import hudson.model.Node;
import hudson.slaves.WorkspaceList;
import jenkins.model.Jenkins;
import hudson.model.Item;
import hudson.model.ItemGroup;
import hudson.model.Items;
import hudson.model.JDK;
import hudson.model.Job;
import hudson.model.Label;
import hudson.model.Queue.FlyweightTask;
import hudson.model.Result;
import hudson.model.SCMedItem;
import hudson.model.Saveable;
import hudson.model.TopLevelItem;
import hudson.tasks.BuildStep;
import hudson.tasks.BuildWrapper;
import hudson.tasks.BuildWrappers;
import hudson.tasks.Builder;
import hudson.tasks.Publisher;
import hudson.triggers.Trigger;
import hudson.util.CopyOnWriteMap;
import hudson.util.DescribableList;
import hudson.util.FormValidation;
import hudson.util.FormValidation.Kind;
import jenkins.scm.SCMCheckoutStrategyDescriptor;
import net.sf.json.JSONObject;
import org.kohsuke.stapler.HttpResponse;
import org.kohsuke.stapler.StaplerRequest;
import org.kohsuke.stapler.StaplerResponse;
import org.kohsuke.stapler.TokenList;
import org.kohsuke.stapler.export.Exported;

import javax.annotation.Nullable;
import javax.servlet.ServletException;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * {@link Job} that allows you to run multiple different configurations
 * from a single setting.
 *
 * @author Kohsuke Kawaguchi
 */
public class MatrixProject extends AbstractProject<MatrixProject,MatrixBuild> implements TopLevelItem, SCMedItem, ItemGroup<MatrixConfiguration>, Saveable, FlyweightTask, BuildableItemWithBuildWrappers {
    /**
     * Configuration axes.
     */
    private volatile AxisList axes = new AxisList();

    /**
     * The filter that is applied to combinations. It is a Groovy if condition.
     * This can be null, which means "true".
     *
     * @see #getCombinationFilter()
     */
    private volatile String combinationFilter;

    /**
     * List of active {@link Builder}s configured for this project.
     */
    private DescribableList<Builder,Descriptor<Builder>> builders =
            new DescribableList<Builder,Descriptor<Builder>>(this);

    /**
     * List of active {@link Publisher}s configured for this project.
     */
    private DescribableList<Publisher,Descriptor<Publisher>> publishers =
            new DescribableList<Publisher,Descriptor<Publisher>>(this);

    /**
     * List of active {@link BuildWrapper}s configured for this project.
     */
    private DescribableList<BuildWrapper,Descriptor<BuildWrapper>> buildWrappers =
            new DescribableList<BuildWrapper,Descriptor<BuildWrapper>>(this);

    /**
     * All {@link MatrixConfiguration}s, keyed by their {@link MatrixConfiguration#getName() names}.
     */
    private transient /*final*/ Map<Combination,MatrixConfiguration> configurations = new CopyOnWriteMap.Tree<Combination,MatrixConfiguration>();

    /**
     * @see #getActiveConfigurations()
     */
    @CopyOnWrite
    private transient /*final*/ Set<MatrixConfiguration> activeConfigurations = new LinkedHashSet<MatrixConfiguration>();

    /**
     * @deprecated as of 1.456
     *      Moved to {@link DefaultMatrixExecutionStrategyImpl}
     */
    private transient Boolean runSequentially;

    /**
     * Filter to select a number of combinations to build first
     * @deprecated as of 1.456
     *      Moved to {@link DefaultMatrixExecutionStrategyImpl}
     */
    private transient String touchStoneCombinationFilter;

    /**
     * Required result on the touchstone combinations, in order to
     * continue with the rest
     * @deprecated as of 1.456
     *      Moved to {@link DefaultMatrixExecutionStrategyImpl}
     */
    private transient Result touchStoneResultCondition;

    /**
     * @deprecated as of 1.456
     *      Moved to {@link DefaultMatrixExecutionStrategyImpl}
     */
    private transient MatrixConfigurationSorter sorter;

    private MatrixExecutionStrategy executionStrategy;

    /**
     * Custom workspace location for {@link MatrixConfiguration}s.
     *
     * <p>
     * (Historically, we used {@link AbstractProject#customWorkspace} + some unique suffix (see {@link MatrixConfiguration#useShortWorkspaceName})
     * for custom workspace, but we now separated that so that the user has more control.
     *
     * <p>
     * If null, the historical semantics is assumed.
     *
     * @since 1.466
     */
    private String childCustomWorkspace;

    public MatrixProject(String name) {
        this(Jenkins.getInstance(), name);
    }

    public MatrixProject(ItemGroup parent, String name) {
        super(parent, name);
    }

    /**
     * Gets the workspace location that {@link MatrixConfiguration} uses.
     *
     * @see MatrixRun.MatrixRunExecution#decideWorkspace(Node, WorkspaceList)
     *
     * @return never null
     *      even when {@link MatrixProject} uses no custom workspace, this method still
     *      returns something like "${PARENT_WORKSPACE}/${COMBINATION}" that controls
     *      how the workspace should be laid out.
     *
     *      The return value can be absolute or relative. If relative, it is resolved
     *      against the working directory of the overarching {@link MatrixBuild}.
     */
    public String getChildCustomWorkspace() {
        String ws = childCustomWorkspace;
        if (ws==null) {
            ws = MatrixConfiguration.useShortWorkspaceName?"${SHORT_COMBINATION}":"${COMBINATION}";
        }
        return ws;
    }

    /**
     * Do we have an explicit child custom workspace setting (true)? Or just using the default value (false)?
     */
    public boolean hasChildCustomWorkspace() {
        return childCustomWorkspace!=null;
    }

    public void setChildCustomWorkspace(String childCustomWorkspace) throws IOException {
        this.childCustomWorkspace = Util.fixEmptyAndTrim(childCustomWorkspace);
        save();
    }

    /**
     * {@link MatrixProject} is relevant with all the labels its configurations are relevant.
     */
    @Override
    public Set<Label> getRelevantLabels() {
        Set<Label> r = new HashSet<Label>();
        for (MatrixConfiguration c : getActiveConfigurations())
            r.add(c.getAssignedLabel());
        return r;
    }

    /**
     * @return can be null (to indicate that the configurations should be left to their natural order.)
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#getSorter()}.
     *      This method tries to emulate the previous behavior the best it can, but will return null
     *      if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public MatrixConfigurationSorter getSorter() {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            return dm.getSorter();
        }
        return null;
    }

    /**
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#setSorter(MatrixConfigurationSorter)}.
     *      This method tries to emulate the previous behavior the best it can, but will fall back
     *      to no-op if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public void setSorter(MatrixConfigurationSorter sorter) throws IOException {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            dm.setSorter(sorter);
            save();
        }
    }

    public AxisList getAxes() {
        return axes;
    }

    /**
     * Reconfigures axes.
     */
    public void setAxes(AxisList axes) throws IOException {
        this.axes = new AxisList(axes);
        rebuildConfigurations(null);
        save();
    }

    public MatrixExecutionStrategy getExecutionStrategy() {
        return executionStrategy;
    }

    public void setExecutionStrategy(MatrixExecutionStrategy executionStrategy) throws IOException {
        if (executionStrategy ==null)   throw new IllegalArgumentException();
        this.executionStrategy = executionStrategy;
        save();
    }

    /**
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#isRunSequentially()}.
     *      This method tries to emulate the previous behavior the best it can, but will return false
     *      if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public boolean isRunSequentially() {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            return dm.isRunSequentially();
        }
        return false;
    }

    /**
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#setRunSequentially(boolean)}.
     *      This method tries to emulate the previous behavior the best it can, but will fall back
     *      to no-op if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public void setRunSequentially(boolean runSequentially) throws IOException {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            dm.setRunSequentially(runSequentially);
            save();
        }
    }

    /**
     * Sets the combination filter.
     *
     * @param combinationFilter the combinationFilter to set
     */
    public void setCombinationFilter(String combinationFilter) throws IOException {
        this.combinationFilter = combinationFilter;
        rebuildConfigurations(null);
        save();
    }

    /**
     * Obtains the combination filter, used to trim down the size of the matrix.
     *
     * <p>
     * By default, a {@link MatrixConfiguration} is created for every possible combination of axes exhaustively.
     * But by specifying a Groovy expression as a combination filter, one can trim down the # of combinations built.
     *
     * <p>
     * Namely, this expression is evaluated for each axis value combination, and only when it evaluates to true,
     * a corresponding {@link MatrixConfiguration} will be created and built.
     *
     * @return can be null.
     * @since 1.279
     */
    public String getCombinationFilter() {
        return combinationFilter;
    }

    /**
     * @return can be null (to indicate that the configurations should be left to their natural order.)
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#getTouchStoneCombinationFilter()}.
     *      This method tries to emulate the previous behavior the best it can, but will return null
     *      if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public String getTouchStoneCombinationFilter() {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            return dm.getTouchStoneCombinationFilter();
        }
        return null;
    }

    /**
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#setTouchStoneCombinationFilter(String)}.
     *      This method tries to emulate the previous behavior the best it can, but will fall back
     *      to no-op if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public void setTouchStoneCombinationFilter(String touchStoneCombinationFilter) throws IOException {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            dm.setTouchStoneCombinationFilter(touchStoneCombinationFilter);
            save();
        }
    }

    /**
     * @return can be null (to indicate that the configurations should be left to their natural order.)
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#getTouchStoneResultCondition()}.
     *      This method tries to emulate the previous behavior the best it can, but will return null
     *      if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public Result getTouchStoneResultCondition() {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            return dm.getTouchStoneResultCondition();
        }
        return null;
    }

    /**
     * @deprecated as of 1.456
     *      Use {@link DefaultMatrixExecutionStrategyImpl#setTouchStoneResultCondition(Result)}.
     *      This method tries to emulate the previous behavior the best it can, but will fall back
     *      to no-op if the current {@link MatrixExecutionStrategy} is not the default one.
     */
    public void setTouchStoneResultCondition(Result touchStoneResultCondition) throws IOException {
        MatrixExecutionStrategy e = executionStrategy;
        if (e instanceof DefaultMatrixExecutionStrategyImpl) {
            DefaultMatrixExecutionStrategyImpl dm = (DefaultMatrixExecutionStrategyImpl) e;
            dm.setTouchStoneResultCondition(touchStoneResultCondition);
            save();
        }
    }

    @Override
    protected List<Action> createTransientActions() {
        List<Action> r = super.createTransientActions();

        for (BuildStep step : builders)
            r.addAll(step.getProjectActions(this));
        for (BuildStep step : publishers)
            r.addAll(step.getProjectActions(this));
        for (BuildWrapper step : buildWrappers)
            r.addAll(step.getProjectActions(this));
        for (Trigger<?> trigger : triggers)
            r.addAll(trigger.getProjectActions());

        return r;
    }
    
    @Override
    protected void updateTransientActions(){
        super.updateTransientActions();
        if(getActiveConfigurations() !=null){
            // update all transient actions in configurations too.
            for(MatrixConfiguration configuration: getActiveConfigurations()){
                configuration.updateTransientActions();
            }
        }
    }

    /**
     * Gets the subset of {@link AxisList} that are not system axes.
     *
     * @deprecated as of 1.373
     *      System vs user difference are generalized into extension point.
     */
    public List<Axis> getUserAxes() {
        List<Axis> r = new ArrayList<Axis>();
        for (Axis a : axes)
            if(!a.isSystem())
                r.add(a);
        return r;
    }

    public Layouter<MatrixConfiguration> getLayouter() {
        return new Layouter<MatrixConfiguration>(axes) {
            protected MatrixConfiguration getT(Combination c) {
                return getItem(c);
            }
        };
    }

    @Override
    public void onCreatedFromScratch() {
        executionStrategy = new DefaultMatrixExecutionStrategyImpl();
        super.onCreatedFromScratch();
    }

    @Override
    public void onLoad(ItemGroup<? extends Item> parent, String name) throws IOException {
        super.onLoad(parent,name);
        Collections.sort(axes); // perhaps the file was edited on disk and the sort order might have been broken
        builders.setOwner(this);
        publishers.setOwner(this);
        buildWrappers.setOwner(this);

        if (executionStrategy ==null)
            executionStrategy = new DefaultMatrixExecutionStrategyImpl(runSequentially,touchStoneCombinationFilter,touchStoneResultCondition,sorter);

        rebuildConfigurations(null);
    }

    @Override
    public void logRotate() throws IOException, InterruptedException {
        super.logRotate();
        // perform the log rotation of inactive configurations to make sure
        // their logs get eventually discarded
        for (MatrixConfiguration config : configurations.values()) {
            if(!config.isActiveConfiguration())
                config.logRotate();
        }
    }

    /**
     * Recursively search for configuration and put them to the map
     *
     * <p>
     * The directory structure would be <tt>axis-a/b/axis-c/d/axis-e/f</tt> for
     * combination [a=b,c=d,e=f]. Note that two combinations [a=b,c=d] and [a=b,c=d,e=f]
     * can both co-exist (where one is an archived record and the other is live, for example)
     * so search needs to be thorough.
     *
     * @param dir
     *      Directory to be searched.
     * @param result
     *      Receives the loaded {@link MatrixConfiguration}s.
     * @param combination
     *      Combination of key/values discovered so far while traversing the directories.
     *      Read-only.
     */
    private void loadConfigurations( File dir, CopyOnWriteMap.Tree<Combination,MatrixConfiguration> result, Map<String,String> combination ) {
        File[] axisDirs = dir.listFiles(new FileFilter() {
            public boolean accept(File child) {
                return child.isDirectory() && child.getName().startsWith("axis-");
            }
        });
        if(axisDirs==null)      return;

        for (File subdir : axisDirs) {
            String axis = subdir.getName().substring(5);    // axis name

            File[] valuesDir = subdir.listFiles(new FileFilter() {
                public boolean accept(File child) {
                    return child.isDirectory();
                }
            });
            if(valuesDir==null) continue;   // no values here

            for (File v : valuesDir) {
                Map<String,String> c = new HashMap<String, String>(combination);
                c.put(axis,TokenList.decode(v.getName()));

                try {
                    XmlFile config = Items.getConfigFile(v);
                    if(config.exists()) {
                        Combination comb = new Combination(c);
                        // if we already have this in memory, just use it.
                        // otherwise load it
                        MatrixConfiguration item=null;
                        if(this.configurations!=null)
                            item = this.configurations.get(comb);
                        if(item==null) {
                            item = (MatrixConfiguration) config.read();
                            item.setCombination(comb);
                            item.onLoad(this, v.getName());
                        }
                        result.put(item.getCombination(), item);
                    }
                } catch (IOException e) {
                    LOGGER.log(Level.WARNING, "Failed to load matrix configuration "+v,e);
                }
                loadConfigurations(v,result,c);
            }
        }
    }

    /**
     * Rebuilds the {@link #configurations} list and {@link #activeConfigurations}.
     *
     * @param context
     *      We rebuild configurations right before a build, to allow configurations to be adjusted for the build.
     *      (think of it as reconfiguring a project right before a build.) And when that happens, this value is the
     *      build in progress. Otherwise this value is null (for example, when Jenkins is booting up.)
     */
    /*package*/ Set<MatrixConfiguration> rebuildConfigurations(MatrixBuildExecution context) throws IOException {
        {
            // backward compatibility check to see if there's any data in the old structure
            // if so, bring them to the newer structure.
            File[] oldDirs = getConfigurationsDir().listFiles(new FileFilter() {
                public boolean accept(File child) {
                    return child.isDirectory() && !child.getName().startsWith("axis-");
                }
            });
            if(oldDirs!=null) {
                // rename the old directory to the new one
                for (File dir : oldDirs) {
                    try {
                        Combination c = Combination.fromString(dir.getName());
                        dir.renameTo(getRootDirFor(c));
                    } catch (IllegalArgumentException e) {
                        // it's not a configuration dir. Just ignore.
                    }
                }
            }
        }

        CopyOnWriteMap.Tree<Combination,MatrixConfiguration> configurations =
            new CopyOnWriteMap.Tree<Combination,MatrixConfiguration>();
        loadConfigurations(getConfigurationsDir(),configurations,Collections.<String,String>emptyMap());
        this.configurations = configurations;

        Iterable<Combination> activeCombinations;
        if (context!=null) {
            List<Set<String>> axesList = Lists.newArrayList();
            for (Axis axis : axes)
                axesList.add(Sets.newLinkedHashSet(axis.rebuild(context)));

            activeCombinations = Iterables.transform(Sets.cartesianProduct(axesList), new Function<List<String>, Combination>() {
                public Combination apply(@Nullable List<String> strings) {
                    assert strings != null;
                    return new Combination(axes, (String[]) strings.toArray(new String[0]));
                }
            });
        } else {
            activeCombinations = axes.list();
        }

        // find all active configurations
        Set<MatrixConfiguration> active = new LinkedHashSet<MatrixConfiguration>();
        for (Combination c : activeCombinations) {
            if(c.evalGroovyExpression(axes,combinationFilter)) {
        		LOGGER.fine("Adding configuration: " + c);
	            MatrixConfiguration config = configurations.get(c);
	            if(config==null) {
	                config = new MatrixConfiguration(this,c);
	                config.save();
	                configurations.put(config.getCombination(), config);
	            }
	            active.add(config);
        	}
        }
        this.activeConfigurations = active;

        return active;
    }

    private File getConfigurationsDir() {
        return new File(getRootDir(),"configurations");
    }

    /**
     * Gets all active configurations.
     *
     * <p>
     * In contract, inactive configurations are those that are left for archival purpose
     * and no longer built when a new {@link MatrixBuild} is executed.
     *
     * <p>
     * During a build, {@link MatrixBuildExecution#getActiveConfigurations()} should be used
     * to make sure that a build is using the consistent set of active configurations from
     * the start to the end.
     */
    @Exported
    public Collection<MatrixConfiguration> getActiveConfigurations() {
        return activeConfigurations;
    }

    public Collection<MatrixConfiguration> getItems() {
        return configurations.values();
    }

    @Override
    public Collection<? extends Job> getAllJobs() {
        Set<Job> jobs = new HashSet<Job>(getItems());
        jobs.add(this);
        return jobs;
    }

    public String getUrlChildPrefix() {
        return ".";
    }

    public MatrixConfiguration getItem(String name) {
        try {
            return getItem(Combination.fromString(name));
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    public MatrixConfiguration getItem(Combination c) {
        return configurations.get(c);
    }

    public File getRootDirFor(MatrixConfiguration child) {
        return getRootDirFor(child.getCombination());
    }

    public void onRenamed(MatrixConfiguration item, String oldName, String newName) throws IOException {
        throw new UnsupportedOperationException();
    }

    public void onDeleted(MatrixConfiguration item) throws IOException {
        // noop
    }

    public File getRootDirFor(Combination combination) {
        File f = getConfigurationsDir();
        for (Entry<String, String> e : combination.entrySet())
            f = new File(f,"axis-"+e.getKey()+'/'+Util.rawEncode(e.getValue()));
        f.getParentFile().mkdirs();
        return f;
    }

    /**
     * @see #getJDKs()
     */
    @Override @Deprecated
    public JDK getJDK() {
        return super.getJDK();
    }

    /**
     * Gets the {@link JDK}s where the builds will be run.
     * @return never null but can be empty
     */
    public Set<JDK> getJDKs() {
        Axis a = axes.find("jdk");
        if(a==null)  return Collections.emptySet();
        Set<JDK> r = new HashSet<JDK>();
        for (String j : a) {
            JDK jdk = Jenkins.getInstance().getJDK(j);
            if(jdk!=null)
                r.add(jdk);
        }
        return r;
    }

    /**
     * Gets the {@link Label}s where the builds will be run.
     * @return never null
     */
    public Set<Label> getLabels() {
        Set<Label> r = new HashSet<Label>();
        for (Combination c : axes.subList(LabelAxis.class).list())
            r.add(Jenkins.getInstance().getLabel(Util.join(c.values(),"&&")));
        return r;
    }

    public List<Builder> getBuilders() {
        return builders.toList();
    }

    public DescribableList<Builder,Descriptor<Builder>> getBuildersList() {
        return builders;
    }

    public Map<Descriptor<Publisher>,Publisher> getPublishers() {
        return publishers.toMap();
    }

    public DescribableList<Publisher,Descriptor<Publisher>> getPublishersList() {
        return publishers;
    }

    public DescribableList<BuildWrapper, Descriptor<BuildWrapper>> getBuildWrappersList() {
        return buildWrappers;
    }

    public Map<Descriptor<BuildWrapper>,BuildWrapper> getBuildWrappers() {
        return buildWrappers.toMap();
    }

    public Publisher getPublisher(Descriptor<Publisher> descriptor) {
        for (Publisher p : publishers) {
            if(p.getDescriptor()==descriptor)
                return p;
        }
        return null;
    }

    protected Class<MatrixBuild> getBuildClass() {
        return MatrixBuild.class;
    }

    public boolean isFingerprintConfigured() {
        return false;
    }

    protected void buildDependencyGraph(DependencyGraph graph) {
        publishers.buildDependencyGraph(this,graph);
        builders.buildDependencyGraph(this,graph);
        buildWrappers.buildDependencyGraph(this,graph);
    }

    public MatrixProject asProject() {
        return this;
    }

    @Override
    public Object getDynamic(String token, StaplerRequest req, StaplerResponse rsp) {
        try {
            MatrixConfiguration item = getItem(token);
            if(item!=null)
            return item;
        } catch (IllegalArgumentException _) {
            // failed to parse the token as Combination. Must be something else
        }
        return super.getDynamic(token,req,rsp);
    }

    @Override
    protected void submit(StaplerRequest req, StaplerResponse rsp) throws IOException, ServletException, FormException {
        super.submit(req, rsp);

        JSONObject json = req.getSubmittedForm();

        if(req.getParameter("hasCombinationFilter")!=null) {
            this.combinationFilter = Util.nullify(req.getParameter("combinationFilter"));
        } else {
            this.combinationFilter = null;
        }

        if(req.hasParameter("customWorkspace")) {
            setChildCustomWorkspace(Util.fixEmptyAndTrim(req.getParameter("childCustomWorkspace.directory")));
        } else {
            setChildCustomWorkspace(null);
        }

        List<MatrixExecutionStrategyDescriptor> esd = getDescriptor().getExecutionStrategyDescriptors();
        if (esd.size()>1)
            executionStrategy = req.bindJSON(MatrixExecutionStrategy.class,json.getJSONObject("executionStrategy"));
        else
            executionStrategy = req.bindJSON(esd.get(0).clazz,json.getJSONObject("executionStrategy"));

        // parse system axes
        DescribableList<Axis,AxisDescriptor> newAxes = new DescribableList<Axis,AxisDescriptor>(this);
        newAxes.rebuildHetero(req, json, Axis.all(),"axis");
        checkAxisNames(newAxes);
        this.axes = new AxisList(newAxes.toList());

        buildWrappers.rebuild(req, json, BuildWrappers.getFor(this));
        builders.rebuildHetero(req, json, Builder.all(), "builder");
        publishers.rebuildHetero(req, json, Publisher.all(), "publisher");

        rebuildConfigurations(null);
    }

    /**
     * Verifies that Axis names are valid and unique.
     */
    private void checkAxisNames(Iterable<Axis> newAxes) throws FormException {
        HashSet<String> axisNames = new HashSet<String>();
        for (Axis a : newAxes) {
            FormValidation fv = a.getDescriptor().doCheckName(a.getName());
            if (fv.kind!=Kind.OK)
                throw new FormException(Messages.MatrixProject_DuplicateAxisName(),fv,"axis.name");

            if (axisNames.contains(a.getName()))
                throw new FormException(Messages.MatrixProject_DuplicateAxisName(),"axis.name");
            axisNames.add(a.getName());
        }
    }

    /**
     * Also delete all the workspaces of the configuration, too.
     */
    @Override
    public HttpResponse doDoWipeOutWorkspace() throws IOException, ServletException, InterruptedException {
        HttpResponse rsp = super.doDoWipeOutWorkspace();
        for (MatrixConfiguration c : configurations.values())
            c.doDoWipeOutWorkspace();
        return rsp;
    }


    public DescriptorImpl getDescriptor() {
        return DESCRIPTOR;
    }

    @Extension
    public static final DescriptorImpl DESCRIPTOR = new DescriptorImpl();

    public static final class DescriptorImpl extends AbstractProjectDescriptor {
        public String getDisplayName() {
            return Messages.MatrixProject_DisplayName();
        }

        public MatrixProject newInstance(ItemGroup parent, String name) {
            return new MatrixProject(parent,name);
        }

        /**
         * All {@link AxisDescriptor}s that contribute to the UI.
         */
        public List<AxisDescriptor> getAxisDescriptors() {
            List<AxisDescriptor> r = new ArrayList<AxisDescriptor>();
            for (AxisDescriptor d : Axis.all()) {
                if (d.isInstantiable())
                    r.add(d);
            }
            return r;
        }

        /**
         * @deprecated as of 1.456
         *      This was only exposed for Jelly.
         */
        public List<MatrixConfigurationSorterDescriptor> getSorterDescriptors() {
            return MatrixConfigurationSorterDescriptor.all();
        }

        public List<MatrixExecutionStrategyDescriptor> getExecutionStrategyDescriptors() {
            return MatrixExecutionStrategyDescriptor.all();
        }

        public List<SCMCheckoutStrategyDescriptor> getMatrixRunCheckoutStrategyDescriptors() {
            return SCMCheckoutStrategyDescriptor.all();
        }
    }

    private static final Logger LOGGER = Logger.getLogger(MatrixProject.class.getName());
}