ClearCaseUcmBaselineParameterValue.java

/*
 * The MIT License
 *
 * Copyright (c) 2010, Manufacture Française des Pneumatiques Michelin, Romain Seguy,
 *                     Amadeus SAS, Vincent Latombe
 * Copyright (c) 2007-2009, Sun Microsystems, Inc., Kohsuke Kawaguchi, Erik Ramfelt,
 *                          Henrik Lynggaard, Peter Liljenberg, Andrew Bayer
 *
 * 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 com.michelin.cio.hudson.plugins.clearcaseucmbaseline;

import hudson.FilePath;
import hudson.Launcher;
import hudson.Util;
import hudson.model.AbstractBuild;
import hudson.model.BuildListener;
import hudson.model.Descriptor;
import hudson.model.Hudson;
import hudson.model.ParameterValue;
import hudson.model.ParametersAction;
import hudson.model.Run;
import hudson.model.TaskListener;
import hudson.plugins.clearcase.AbstractClearCaseScm;
import hudson.plugins.clearcase.ClearToolLauncher;
import hudson.plugins.clearcase.HudsonClearToolLauncher;
import hudson.plugins.clearcase.PluginImpl;
import hudson.plugins.clearcase.ucm.UcmMakeBaseline;
import hudson.plugins.clearcase.ucm.UcmMakeBaselineComposite;
import hudson.plugins.clearcase.util.PathUtil;
import hudson.tasks.BuildWrapper;
import hudson.tasks.Publisher;
import hudson.util.DescribableList;
import hudson.util.VariableResolver;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.kohsuke.stapler.DataBoundConstructor;
import org.kohsuke.stapler.export.Exported;

/**
 * This class represents the actual {@link ParameterValue} for the
 * {@link ClearCaseUcmBaselineParameterDefinition} parameter.
 *
 * <p>This value holds the following information:
 * <li>The ClearCase UCM PVOB name (which is actually defined at config-time —
 * cf. {@link ClearCaseUcmBaselineParameterDefinition});</li>
 * <li>The ClearCase UCM component name (which is actually defined at config-time
 * — cf. {@link ClearCaseUcmBaselineParameterDefinition});</li>
 * <li>The ClearCase UCM promotion level (which is actually defined at config-time
 * — cf. {@link ClearCaseUcmBaselineParameterDefinition});</li>
 * <li>The ClearCase UCM view to create name (which is actually defined at config-time
 * — cf. {@link ClearCaseUcmBaselineParameterDefinition});</li>
 * <li>The ClearCase UCM baseline (this is the only one information which is
 * asked at build-time)</li>
 * </ul></p>
 *
 * @author Romain Seguy (http://openromain.blogspot.com)
 */
public class ClearCaseUcmBaselineParameterValue extends ParameterValue {

    // TODO move the attributes of this class and of ClearCaseUcmBaselineParameterDefinition
    // to a single dedicated class to avoid having too much duplicated code
    @Exported(visibility=3) private String baseline;        // this att is set by the user once the build takes place
    @Exported(visibility=3) private String component;       // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private boolean excludeElementCheckedout; // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private boolean forceRmview;    // this att can be overriden by the user but default value
                                                            // comes from ClearCaseUcmBaselineParameterDefinition
    private String mkviewOptionalParam;                     // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private String promotionLevel;  // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private String pvob;            // this att comes from ClearCaseUcmBaselineParameterDefinition
    private List<String> restrictions;                      // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private boolean snapshotView;   // this att comes from ClearCaseUcmBaselineParameterDefinition
    private String stream;                                  // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private boolean useUpdate;      // this att comes from ClearCaseUcmBaselineParameterDefinition
    @Exported(visibility=3) private String viewName;        // this att comes from ClearCaseUcmBaselineParameterDefinition

    private StringBuffer fatalErrorMessage = new StringBuffer();

    // I have to have two constructors: If I use only one (the most complete one),
    // I get an exception in ClearCaseUcmBaselineParameterDefinition.createValue(StaplerRequest, JSONObject)
    // while invoking req.bindJSON()
    // Is it because of the two booleans? No time to investigate, sorry.
    @DataBoundConstructor
    public ClearCaseUcmBaselineParameterValue(String name, String baseline, boolean forceRmview) {
        this(name, null, null, null, null, null, null, baseline, false, forceRmview, false, false);
    }

    public ClearCaseUcmBaselineParameterValue(
            String name, String pvob, String component, String promotionLevel,
            String stream, String viewName, String mkviewOptionalParam, String baseline,
            boolean useUpdate, boolean forceRmview, boolean snapshotView,
            boolean excludeElementCheckedout) {
        super(name);
        this.pvob = ClearCaseUcmBaselineUtils.prefixWithSeparator(pvob);
        this.component = component;
        this.promotionLevel = promotionLevel;
        this.stream = stream;
        this.viewName = viewName;
        this.mkviewOptionalParam = mkviewOptionalParam;
        this.baseline = baseline;
        this.useUpdate = useUpdate;
        this.forceRmview = forceRmview;
        this.snapshotView = snapshotView;
        if(this.snapshotView) {
            // the "element * CHECKEDOUT" rule is mandatory for snapshot views
            this.excludeElementCheckedout = true;
        }
        else {
            this.excludeElementCheckedout = excludeElementCheckedout;
        }
    }

    /**
     * Returns the {@link BuildWrapper} (defined as an inner class) which does
     * the "checkout" from the ClearCase UCM baseline selected by the user.
     *
     * <p>If a {@link ClearCaseUcmBaselineParameterDefinition} is added for the
     * build but the SCM is not {@link ClearCaseUcmBaselineSCM}, then the
     * {@link BuildWrapper} which is returned will make the build fail.</p>
     */
    @Override
    public BuildWrapper createBuildWrapper(AbstractBuild<?, ?> build) {
        // let's ensure that a baseline has been really provided
        if(baseline == null || baseline.length() == 0) {
            fatalErrorMessage.append("The value '" + baseline + "' is not a valid ClearCase UCM baseline.");
        }

        // HUDSON-5877: let's ensure the job has no publishers/notifiers coming
        // from the ClearCase plugin
        DescribableList<Publisher, Descriptor<Publisher>> publishersList = build.getProject().getPublishersList();
        for(Publisher publisher : publishersList) {
            if(publisher instanceof UcmMakeBaseline || publisher instanceof UcmMakeBaselineComposite) {
                if(fatalErrorMessage.length() > 0) {
                    fatalErrorMessage.append('\n');
                }
                fatalErrorMessage.append("This job is set up to use a '").append(publisher.getDescriptor().getDisplayName()).append(
                        "' publisher which is not compatible with the ClearCase UCM baseline SCM mode. Please remove this publisher.");
            }
        }
        if(fatalErrorMessage.length() > 0) {
            return new BuildWrapper() {
                /**
                 * This method just makes the build fail for various reasons.
                 */
                @Override
                public Environment setUp(AbstractBuild build, Launcher launcher, BuildListener listener) throws IOException, InterruptedException {
                    listener.fatalError(fatalErrorMessage.toString());
                    return null;
                }
            };
        }

        if(build.getProject().getScm() instanceof ClearCaseUcmBaselineSCM) {
            // the job is apparently set-up in a clean way, the build can take place
            return new BuildWrapper() {

                private ClearToolLauncher createClearToolLauncher(TaskListener listener, FilePath workspace, Launcher launcher) {
                    return new HudsonClearToolLauncher(
                            PluginImpl.getDescriptor().getCleartoolExe(),
                            Hudson.getInstance().getDescriptor(ClearCaseUcmBaselineSCM.class).getDisplayName(),
                            listener,
                            workspace,
                            launcher);
                }

                /**
                 * This method is a copy of {@link AbstractClearCaseScm#generateNormalizedViewName}
                 * which is unfortunately not static.
                 *
                 * @see AbstractClearCaseScm#generateNormalizedViewName
                 */
                private String generateNormalizedViewName(VariableResolver variableResolver, String viewName) {
                    String normalizedViewName = Util.replaceMacro(viewName, variableResolver);
                    normalizedViewName = normalizedViewName.replaceAll("[\\s\\\\\\/:\\?\\*\\|]+", "_");
                    return normalizedViewName;
                }

                /**
                 * This method is the one which actually does the ClearCase stuff
                 * (creating the view, setting the config spec, downloading the
                 * view, etc.).
                 *
                 * <p>This method is invoked when the user clicks on the 'Build'
                 * button appearing on the parameters page.</p>
                 */
                @Override
                public Environment setUp(AbstractBuild build, final Launcher launcher, BuildListener listener) throws IOException, InterruptedException {
                    // we use our own variable resolver to have the support for
                    // the CLEARCASE_BASELINE env variable (cf. HUDSON-6410)
                    VariableResolver variableResolver = new BuildVariableResolver(build, launcher, listener, baseline);

                    ClearToolLauncher clearToolLauncher = createClearToolLauncher(listener, build.getProject().getWorkspace(), launcher);
                    ClearToolUcmBaseline cleartool = new ClearToolUcmBaseline(variableResolver, clearToolLauncher);

                    viewName = generateNormalizedViewName(variableResolver, viewName);

                    FilePath workspace = build.getProject().getWorkspace();
                    FilePath viewPath = workspace.child(viewName);
                    StringBuilder configSpec = new StringBuilder();

                    // --- 0. Has the same baseline been retrieved during last execution? ---

                    boolean lastBuildUsedSameBaseline = false;

                    if(forceRmview == false) { // we care only if we don't want to remove the existing view
                        ClearCaseUcmBaselineParameterValue lastCcParamValue = null;

                        // tons of loops and ifs to find the ClearCaseUcmBaselineParameterValue of the last build, if any
                        List<Run> builds = build.getProject().getBuilds();
                        if(builds.size() > 1) {
                            Run latestBuild = builds.get(1); // builds.get(0) is the currently running build
                            List<ParametersAction> actions = latestBuild.getActions(ParametersAction.class);
                            if(actions != null) {
                                for(ParametersAction action : actions) {
                                    List<ParameterValue> parameters = action.getParameters();
                                    if(parameters != null) {
                                        for(ParameterValue parameter : parameters) {
                                            if(parameter instanceof ClearCaseUcmBaselineParameterValue) {
                                                lastCcParamValue = (ClearCaseUcmBaselineParameterValue) parameter;
                                                // there can be only one time this kind of parameter, so let's break
                                                break;
                                            }
                                        }
                                    }

                                    if(lastCcParamValue != null) {
                                        // there can be only one time this kind of parameter, so let's break here too
                                        break;
                                    }
                                }
                            }
                        }

                        if(lastCcParamValue != null) {
                            if(pvob.equals(lastCcParamValue.pvob)
                                    && component.equals(lastCcParamValue.component)
                                    && baseline.equals(lastCcParamValue.baseline)) {
                                // the baseline used in the latest build is the same as the newly requested one
                                lastBuildUsedSameBaseline = true;
                            }
                        }
                    }

                    final String newlineForOS = launcher.isUnix() ? "\n" : "\r\n";
                    // we assume that the slave OS file separator is the same as the server
                    // since we have no way of determining the OS of the Clearcase server
                    final String fileSepForOS = PathUtil.fileSepForOS(launcher.isUnix());

                    if(forceRmview || !lastBuildUsedSameBaseline || !viewPath.exists()) {
                        // --- 1. We remove the view if it already exists ---

                        if(viewPath.exists()) {
                            if(!useUpdate || forceRmview) {
                                cleartool.rmview(viewName);

                                // --- 2. We create the view to be loaded ---

                                cleartool.mkview(viewName, mkviewOptionalParam, snapshotView, null);
                            }
                        } else {
                            cleartool.mkview(viewName, mkviewOptionalParam, snapshotView, null);
                        }

                        // --- 3. We create the configspec ---

                        if(!excludeElementCheckedout) {
                            configSpec.append("element * CHECKEDOUT").append(newlineForOS);
                        }

                        Set<String> loadRules = new HashSet<String>(); // we use a Set to avoid duplicate load rules (cf. HUDSON-6398)

                        // cleartool lsbl -fmt "%[depends_on_closure]p" <baseline>@<pvob>
                        String[] dependentBaselines = cleartool.getDependentBaselines(pvob, baseline);

                        // we add the selected baseline at the beginning of the dependentBaselines
                        // array so that the "element" and "load" sections of the config spec are
                        // generated for this baseline
                        dependentBaselines = (String[]) ArrayUtils.add(dependentBaselines, 0, baseline + '@' + pvob);

                        for(String dependentBaselineSelector: dependentBaselines) {
                            int indexOfSeparator = dependentBaselineSelector.indexOf('@');
                            if(indexOfSeparator == -1) {
                                if(LOGGER.isLoggable(Level.INFO)) {
                                    LOGGER.info("Ignoring dependent baseline '" + dependentBaselineSelector + '\'');
                                }
                                continue;
                            }

                            String dependentBaseline = dependentBaselineSelector.substring(0, indexOfSeparator);
                            String component = cleartool.getComponentFromBaseline(pvob, dependentBaseline);
                            String componentRootDir = cleartool.getComponentRootDir(pvob, component);

                            // some components may be rootless: they must simply be skipped (cf. HUDSON-6398)
                            if(StringUtils.isBlank(componentRootDir)) {
                                continue;
                            }

                            // example of generated config spec "element":
                            // element /xxx/spd_comp/... spd_comp_v1.x_20100402100000 -nocheckout
                            configSpec.append("element \"").append(componentRootDir).append(fileSepForOS).append("...\" ").append(dependentBaseline).append(" -nocheckout").append(newlineForOS);
                            // is any download restriction defined?
                            if(restrictions != null && restrictions.size() > 0) {
                                for(String restriction: restrictions) {
                                    // the comparison must not take into account path separators,
                                    // so let's unify them to / for that purpose
                                    String restrictionForComparison = restriction.replace('\\', '/');
                                    String componentRootDirForComparison = componentRootDir.replace('\\', '/');
                                    if(restrictionForComparison.startsWith(componentRootDirForComparison)) {
                                        // example of generated config spec "load":
                                        // load /xxx/spd_comp/src
                                        loadRules.add("load " + restriction);
                                    }
                                }
                            }
                            else {
                                loadRules.add("load " + componentRootDir);
                            }
                        }

                        configSpec.append("element * /main/0 -ucm -nocheckout").append(newlineForOS);
                        for(String loadRule: loadRules) {
                            configSpec.append(loadRule).append(newlineForOS);
                        }

                        listener.getLogger().println("The view will be created based on the following config spec:");
                        listener.getLogger().println("--- config spec start ---");
                        listener.getLogger().print(configSpec.toString());
                        listener.getLogger().println("---  config spec end  ---");

                        // --- 4. We actually load the view based on the configspec ---

                        // cleartool setcs <configspec>
                        cleartool.setcs(viewName, configSpec.toString());
                    }
                    else {
                        listener.getLogger().println("The requested ClearCase UCM baseline is the same as previous build: Reusing previously loaded view");
                    }

                    // --- 5. Create the environment variables ---

                    return new Environment() {
                        @Override
                        public void buildEnvVars(Map<String, String> env) {
                            env.put(ClearCaseUcmBaselineSCM.CLEARCASE_BASELINE_ENVSTR,
                                    baseline);
                            env.put(AbstractClearCaseScm.CLEARCASE_VIEWNAME_ENVSTR,
                                    viewName);

                            env.put(AbstractClearCaseScm.CLEARCASE_VIEWPATH_ENVSTR,
                                    env.get("WORKSPACE") + fileSepForOS + viewName);
                        }
                    };
                }

            };
        }
        else {
            return new BuildWrapper() {
                /**
                 * This method makes the build fail when a {@link ClearCaseUcmBaselineParameterDefinition}
                 * parameter is defined for the job, but the SCM is not an instance
                 * of {@link ClearCaseUcmBaselineSCM}.
                 */
                @Override
                public Environment setUp(AbstractBuild build, Launcher launcher, BuildListener listener) throws IOException, InterruptedException {
                    String ccUcmBaselineSCMDisplayName = Hudson.getInstance().getDescriptor(ClearCaseUcmBaselineSCM.class).getDisplayName();
                    listener.fatalError(
                            "This job is not set up to use a '"
                            + ccUcmBaselineSCMDisplayName
                            + "' SCM while it has a '"
                            + Hudson.getInstance().getDescriptor(ClearCaseUcmBaselineParameterDefinition.class).getDisplayName()
                            + "' parameter: Either remove the parameter or set the SCM to be '"
                            + ccUcmBaselineSCMDisplayName
                            + "'; In the meantime: Aborting!");
                    return null;
                } 
            };
        }
    }

    public String getBaseline() {
        return baseline;
    }

    public void setBaseline(String baseline) {
        this.baseline = baseline;
    }

    public String getComponent() {
        return component;
    }

    public void setComponent(String component) {
        this.component = component;
    }

    public boolean getExcludeElementCheckedout() {
        return excludeElementCheckedout;
    }

    public void setExcludeElementCheckedout(boolean excludeElementCheckedout) {
        this.excludeElementCheckedout = excludeElementCheckedout;
    }

    public boolean getForceRmview() {
        return forceRmview;
    }

    public void setForceRmview(boolean forceRmview) {
        this.forceRmview = forceRmview;
    }

    public String getMkviewOptionalParam() {
        return mkviewOptionalParam;
    }

    public void setMkviewOptionalParam(String mkviewOptionalParam) {
        this.mkviewOptionalParam = mkviewOptionalParam;
    }

    public String getPromotionLevel() {
        return promotionLevel;
    }

    public void setPromotionLevel(String promotionLevel) {
        this.promotionLevel = promotionLevel;
    }

    public String getPvob() {
        return pvob;
    }

    public void setPvob(String pvob) {
        this.pvob = pvob;
    }

    public void setRestrictions(List<String> restrictions) {
        this.restrictions = restrictions;
    }

    public boolean getSnapshotView() {
        return snapshotView;
    }

    public void setSnapshotView(boolean snapshotView) {
        this.snapshotView = snapshotView;
    }

    public String getStream() {
        return stream;
    }

    public void setStream(String stream) {
        this.stream = stream;
    }

    public boolean getUseUpdate() {
        return useUpdate;
    }

    public void setUseUpdate(boolean useUpdate) {
        this.useUpdate = useUpdate;
    }

    public String getViewName() {
        return viewName;
    }

    public void setViewName(String viewName) {
        this.viewName = viewName;
    }

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

}