/** {@inheritDoc} */ @Override public boolean isSelectable(Run<?, ?> run, EnvVars env) { EnvVars otherEnv; try { otherEnv = run.getEnvironment(TaskListener.NULL); } catch (Exception ex) { return false; } if (!(run instanceof AbstractBuild)) { // Abstract#getEnvironment(TaskListener) put build parameters to // environments, but Run#getEnvironment(TaskListener) doesn't. // That means we can't retrieve build parameters from WorkflowRun // as it is a subclass of Run, not of AbstractBuild. // We need expand build parameters manually. // See JENKINS-26694 for details. for (ParametersAction pa : run.getActions(ParametersAction.class)) { // We have to extract parameters manually as ParametersAction#buildEnvVars // (overrides EnvironmentContributingAction#buildEnvVars) // is applicable only for AbstractBuild. for (ParameterValue pv : pa.getParameters()) { pv.buildEnvironment(run, otherEnv); } } } for (StringParameterValue spv : filters) { if (!spv.value.equals(otherEnv.get(spv.getName()))) { return false; } } return true; }
private void triggerAllBuildsConcurrent(AbstractBuild build, BuildListener listener) { final List<String> newBuildNodes = new ArrayList<String>(); final ParametersAction origParamsAction = build.getAction(ParametersAction.class); final List<ParameterValue> origParams = origParamsAction.getParameters(); final List<ParameterValue> newPrams = new ArrayList<ParameterValue>(); for (ParameterValue parameterValue : origParams) { if (parameterValue instanceof LabelParameterValue) { if (parameterValue instanceof NodeParameterValue) { NodeParameterValue origNodePram = (NodeParameterValue) parameterValue; List<String> nextNodes = origNodePram.getNextLabels(); if (nextNodes != null) { listener.getLogger().print("next nodes: " + nextNodes); newBuildNodes.addAll(nextNodes); } } } else { newPrams.add(parameterValue); } } for (String nodeName : newBuildNodes) { final List<String> singleNodeList = new ArrayList<String>(); singleNodeList.add(nodeName); final NodeParameterValue nodeParameterValue = new NodeParameterValue(nodeName, singleNodeList); List<ParameterValue> copies = new ArrayList<ParameterValue>(newPrams); copies.add(nodeParameterValue); // where to do the next build listener.getLogger().print("schedule build on node " + nodeName); build .getProject() .scheduleBuild(0, new NextLabelCause(nodeName), new ParametersAction(copies)); } }
/** * @param project * @param commitSHA1 * @return */ private Run getBuildBySHA1(Job project, String commitSHA1, boolean triggeredByMergeRequest) { List<Run> builds = project.getBuilds(); for (Run build : builds) { BuildData data = build.getAction(BuildData.class); MergeRecord mergeRecord = build.getAction(MergeRecord.class); if (mergeRecord == null) { // Determine if build was triggered by a Merge Request event ParametersAction params = build.getAction(ParametersAction.class); if (params == null) continue; StringParameterValue sourceBranch = (StringParameterValue) params.getParameter("gitlabSourceBranch"); StringParameterValue targetBranch = (StringParameterValue) params.getParameter("gitlabTargetBranch"); boolean isMergeRequestBuild = (sourceBranch != null && !sourceBranch.value.equals(targetBranch.value)); if (!triggeredByMergeRequest) { if (isMergeRequestBuild) // skip Merge Request builds continue; if (data.getLastBuiltRevision().getSha1String().contains(commitSHA1)) { return build; } } else { if (!isMergeRequestBuild) // skip Push builds continue; if (hasBeenBuilt(data, ObjectId.fromString(commitSHA1), build)) { return build; } } } else { Build b = data.lastBuild; boolean isMergeBuild = mergeRecord != null && !mergeRecord.getSha1().equals(b.getMarked().getSha1String()); if (b != null && b.getMarked() != null && b.getMarked().getSha1String().equals(commitSHA1)) { if (triggeredByMergeRequest == isMergeBuild) { LOGGER.log( Level.FINE, build.getNumber() + " Build found matching " + commitSHA1 + " " + (isMergeBuild ? "merge" : "normal") + " build"); return build; } } } } return null; }
private BuildData getBuildData(StringParameterValue pullRequestUrlParam) { for (Run<?, ?> build : project.getBuilds()) { ParametersAction paramsAction = build.getAction(ParametersAction.class); if (paramsAction != null) { for (ParameterValue param : paramsAction.getParameters()) { if (param.equals(pullRequestUrlParam)) { List<BuildData> buildDataList = build.getActions(BuildData.class); if (!buildDataList.isEmpty()) { return buildDataList.get(0); } } } } } return null; }
private void populateWithParameters(Run build, String externalizableId) { ParametersAction action = build.getAction(ParametersAction.class); if (action != null) { List<ParameterValue> parameters = action.getParameters(); if (parameters != null) { for (ParameterValue parameter : parameters) { if (parameter instanceof StringParameterValue) { put( "parameter-" + parameter.getName(), ((StringParameterValue) parameter).value, externalizableId); } } } } }
@SuppressWarnings("unchecked") public boolean matchesRun(Run run) { ParametersAction action = run.getAction(ParametersAction.class); if (action == null) { return false; } // look for one parameter value that matches our criteria for (ParameterValue value : action.getParameters()) { String sval = getStringValue(value); if (matchesParameter(value.getName(), sval, false, null)) { return true; } } // no parameters matched the criteria return false; }
private String getSingleBranch(AbstractBuild<?, ?> build) { // if we have multiple branches skip to advanced usecase if (getBranches().size() != 1 || getRepositories().size() != 1) return null; String branch = getBranches().get(0).getName(); String repository = getRepositories().get(0).getName(); // replace repository wildcard with repository name if (branch.startsWith("*/")) branch = repository + branch.substring(1); // if the branch name contains more wildcards then the simple usecase // does not apply and we need to skip to the advanced usecase if (branch.contains("*")) return null; // substitute build parameters if available ParametersAction parameters = build.getAction(ParametersAction.class); if (parameters != null) branch = parameters.substitute(build, branch); return branch; }
/** * Method for getting the ParameterValue instance from ParameterDefinition or ParamterAction. * * @param paramDefProp ParametersDefinitionProperty * @param parameterName Name of the Parameter. * @param paramAction ParametersAction * @param req StaplerRequest * @param jo JSONObject * @return ParameterValue instance of subclass of ParameterValue */ public ParameterValue getParameterValue( ParametersDefinitionProperty paramDefProp, String parameterName, ParametersAction paramAction, StaplerRequest req, JSONObject jo) { ParameterDefinition paramDef; // this is normal case when user try to rebuild a parameterized job. if (paramDefProp != null) { paramDef = paramDefProp.getParameterDefinition(parameterName); if (paramDef != null) { // The copy artifact plugin throws an exception when using createValue(req, jo) // If the parameter comes from the copy artifact plugin, then use the single argument // createValue if (jo.toString().contains("BuildSelector") || jo.toString().contains("WorkspaceSelector")) { SimpleParameterDefinition parameterDefinition = (SimpleParameterDefinition) paramDefProp.getParameterDefinition(parameterName); return parameterDefinition.createValue(jo.getString("value")); } return paramDef.createValue(req, jo); } } /* * when user try to rebuild a build that was invoked by * parameterized trigger plugin in that case ParameterDefinition * is null for that parametername that is paased by parameterize * trigger plugin,so for handling that scenario, we need to * create an instance of that specific ParameterValue with * passed parameter value by form. * * In contrast to all other parameterActions, ListSubversionTagsParameterValue uses "tag" instead of "value" */ if (jo.containsKey("value")) { return cloneParameter(paramAction.getParameter(parameterName), jo.getString("value")); } else { return cloneParameter(paramAction.getParameter(parameterName), jo.getString("tag")); } }
private void triggerBuilds(AbstractBuild build, BuildListener listener) { final ParametersAction origParamsAction = build.getAction(ParametersAction.class); final List<ParameterValue> origParams = origParamsAction.getParameters(); final List<ParameterValue> newPrams = new ArrayList<ParameterValue>(); boolean triggerNewBuild = false; NextLabelCause nextLabelCause = null; for (ParameterValue parameterValue : origParams) { if (parameterValue instanceof LabelParameterValue) { if (parameterValue instanceof NodeParameterValue) { NodeParameterValue origNodePram = (NodeParameterValue) parameterValue; final List<String> nextNodes = origNodePram.getNextLabels(); if (nextNodes != null && !nextNodes.isEmpty() && shouldScheduleNextJob(build.getResult(), triggerIfResult)) { NodeParameterValue newNodeParam = new NodeParameterValue(origNodePram.getName(), nextNodes); newPrams.add(newNodeParam); final String nextLabel = newNodeParam.getLabel(); if (nextLabel != null) { listener.getLogger().print("schedule single build on node " + nextLabel); nextLabelCause = new NextLabelCause(nextLabel); triggerNewBuild = true; } else { LOGGER.severe( "can't trigger next build because next label could not be determined!"); } } } } else { newPrams.add(parameterValue); } } if (triggerNewBuild) { // schedule the next build right away... // the ParametersAction will also contain the labels for the // next builds build.getProject().scheduleBuild(0, nextLabelCause, new ParametersAction(newPrams)); } }
@Test public void testRebuild() throws Exception { // job with promotion process FreeStyleProject p1 = j.createFreeStyleProject("promojob"); // setup promotion process JobPropertyImpl promotion = new JobPropertyImpl(p1); p1.addProperty(promotion); PromotionProcess proc = promotion.addProcess("promo"); proc.conditions.add(new SelfPromotionCondition(false)); // build it FreeStyleBuild b1 = j.assertBuildStatusSuccess(p1.scheduleBuild2(0)); j.waitUntilNoActivity(); // verify that promotion happened Assert.assertSame(proc.getBuilds().getLastBuild().getTarget(), b1); // job with parameter FreeStyleProject p2 = j.createFreeStyleProject("paramjob"); // add promoted build param p2.addProperty( new ParametersDefinitionProperty( new PromotedBuildParameterDefinition( "var", "promojob", "promo", "promoted build param to test rebuild"))); // build with parameter FreeStyleBuild b2 = j.assertBuildStatusSuccess(p2.scheduleBuild2(0)); // validate presence of parameter ParametersAction a1 = b2.getAction(ParametersAction.class); Assert.assertNotNull(a1); Assert.assertFalse(a1.getParameters().isEmpty()); ParameterValue v1 = a1.getParameter("var"); Assert.assertTrue(v1 instanceof PromotedBuildParameterValue); PromotedBuildParameterValue pbpv1 = (PromotedBuildParameterValue) v1; Assert.assertEquals(b1.getNumber(), pbpv1.getRun().getNumber()); // rebuild it JenkinsRule.WebClient wc = j.createWebClient(); HtmlPage page = wc.getPage(b2, "rebuild"); HtmlForm form = page.getFormByName("config"); j.submit(form); j.waitUntilNoActivity(); // validate presence of parameter FreeStyleBuild rebuild = p2.getLastBuild(); j.assertBuildStatusSuccess(rebuild); Assert.assertNotEquals(b2.getNumber(), rebuild.getNumber()); ParametersAction a2 = rebuild.getAction(ParametersAction.class); Assert.assertNotNull(a2); Assert.assertFalse(a2.getParameters().isEmpty()); ParameterValue v2 = a2.getParameter("var"); Assert.assertTrue(v2 instanceof PromotedBuildParameterValue); PromotedBuildParameterValue pbpv2 = (PromotedBuildParameterValue) v2; Assert.assertEquals(b1.getNumber(), pbpv2.getRun().getNumber()); }
@Test public void test() throws IOException { Project project = r.createFreeStyleProject("project"); project.addProperty( new ParametersDefinitionProperty( new StringParameterDefinition("key1", "value1"), new StringParameterDefinition("key2", "value2"))); ParametersAction action = new ParametersAction( new StringParameterValue("key2", "not-value2"), new StringParameterValue("key3", "value3")); DefaultParameterValuesActionsTransform transform = new DefaultParameterValuesActionsTransform(); ParametersAction result = transform.transformParametersAction(action, project); assertEquals(3, result.getParameters().size()); assertStringParameterValueEquals("value1", result.getParameter("key1")); assertStringParameterValueEquals("not-value2", result.getParameter("key2")); assertStringParameterValueEquals("value3", result.getParameter("key3")); }
public String getBuildParams(SubBuild subBuild) { AbstractProject project = (AbstractProject) Jenkins.getInstance().getItem(subBuild.getJobName()); Run build = project.getBuildByNumber(subBuild.getBuildNumber()); ParametersAction action = build.getAction(ParametersAction.class); List<ParameterValue> parameters = action.getParameters(); StringBuffer buffer = new StringBuffer(); for (ParameterValue parameterValue : parameters) { StringParameterValue stringParameter; try { stringParameter = ((StringParameterValue) parameterValue); } catch (Exception e) { continue; } String value = stringParameter.value; String name = stringParameter.getName(); buffer .append("<input type='text' size='15' value='" + name + "' readonly/>") .append(" ") .append("<input type='text' size='35' value='" + value + "'/ readonly>") .append("</br>"); } return buffer.toString(); }
@Override protected Result doRun(final BuildListener listener) throws Exception { PrintStream logger = listener.getLogger(); try { EnvVars envVars = getEnvironment(listener); Config config = IvyConfig.provider.getConfigById(project.getSettings()); if (config != null) { FilePath tmp = getWorkspace().createTextTempFile("ivy", "xml", config.content); settings = tmp.getRemote(); addAction(new CleanTempFilesAction(settings)); } else { String settingsFile = project.getIvySettingsFile(); if (settingsFile != null) { settings = getWorkspace().child(settingsFile).getRemote(); } } if (!project.isAggregatorStyleBuild()) { // start module builds parseIvyDescriptorFiles(listener, logger, envVars); Set<IvyModule> triggeredModules = new HashSet<IvyModule>(); if (!project.isIncrementalBuild() || IvyModuleSetBuild.this.getChangeSet().isEmptySet()) { for (IvyModule module : project.sortedActiveModules) { // Don't trigger builds if we've already triggered // one // of their dependencies. // It's safe to just get the direct dependencies // since // the modules are sorted in dependency order. List<AbstractProject> ups = module.getUpstreamProjects(); boolean triggerBuild = true; for (AbstractProject upstreamDep : ups) { if (triggeredModules.contains(upstreamDep)) { triggerBuild = false; break; } } if (triggerBuild) { logger.println("Triggering " + module.getModuleName()); module.scheduleBuild( new ParameterizedUpstreamCause( ((Run<?, ?>) IvyModuleSetBuild.this), IvyModuleSetBuild.this.getActions(ParametersAction.class))); } triggeredModules.add(module); } } else { for (IvyModule module : project.sortedActiveModules) { // If there are changes for this module, add it. // Also add it if we've never seen this module // before, // or if the previous build of this module // failed or was unstable. boolean triggerBuild = false; if ((module.getLastBuild() == null) || (!getChangeSetFor(module).isEmpty()) || (module.getLastBuild().getResult().isWorseThan(Result.SUCCESS))) { triggerBuild = true; List<AbstractProject> ups = module.getUpstreamProjects(); for (AbstractProject upstreamDep : ups) { if (triggeredModules.contains(upstreamDep)) { triggerBuild = false; triggeredModules.add(module); break; } } } if (triggerBuild) { logger.println("Triggering " + module.getModuleName()); module.scheduleBuild( new ParameterizedUpstreamCause( ((Run<?, ?>) IvyModuleSetBuild.this), IvyModuleSetBuild.this.getActions(ParametersAction.class))); triggeredModules.add(module); } } } } else { // do builds here try { List<BuildWrapper> wrappers = new ArrayList<BuildWrapper>(); for (BuildWrapper w : project.getBuildWrappersList()) wrappers.add(w); ParametersAction parameters = getAction(ParametersAction.class); if (parameters != null) parameters.createBuildWrappers(IvyModuleSetBuild.this, wrappers); for (BuildWrapper w : wrappers) { Environment e = w.setUp(IvyModuleSetBuild.this, launcher, listener); if (e == null) return Result.FAILURE; buildEnvironments.add(e); e.buildEnvVars(envVars); // #3502: too late for // getEnvironment to do // this } if (!preBuild(listener, project.getPublishers())) return Result.FAILURE; Properties additionalProperties = null; if (project.isIncrementalBuild()) { parseIvyDescriptorFiles(listener, logger, envVars); List<String> changedModules = new ArrayList<String>(); for (IvyModule m : project.sortedActiveModules) { // Check if incrementalBuild is selected and that // there are changes - // we act as if incrementalBuild is not set if there // are no changes. if (!IvyModuleSetBuild.this.getChangeSet().isEmptySet()) { // If there are changes for this module, add it. if (!getChangeSetFor(m).isEmpty()) { changedModules.add(m.getModuleName().name); } } } if (project.isAggregatorStyleBuild()) { additionalProperties = new Properties(); additionalProperties.put( project.getChangedModulesProperty() == null ? "hudson.ivy.changedModules" : project.getChangedModulesProperty(), StringUtils.join(changedModules, ',')); } } IvyBuilderType ivyBuilderType = project.getIvyBuilderType(); hudson.tasks.Builder builder = ivyBuilderType.getBuilder(additionalProperties, null, buildEnvironments); logger.println( "Building project with " + ivyBuilderType.getDescriptor().getDisplayName()); if (builder.perform(IvyModuleSetBuild.this, launcher, listener)) return Result.SUCCESS; return Result.FAILURE; } finally { // tear down in reverse order boolean failed = false; for (int i = buildEnvironments.size() - 1; i >= 0; i--) { if (!buildEnvironments.get(i).tearDown(IvyModuleSetBuild.this, listener)) { failed = true; } } buildEnvironments = null; // WARNING The return in the finally clause will trump // any return before if (failed) return Result.FAILURE; } } return null; } catch (AbortException e) { if (e.getMessage() != null) listener.error(e.getMessage()); return Result.FAILURE; } catch (InterruptedIOException e) { e.printStackTrace(listener.error("Aborted Ivy execution for InterruptedIOException")); return Result.ABORTED; } catch (InterruptedException e) { e.printStackTrace(listener.error("Aborted Ivy execution for InterruptedException")); return Result.ABORTED; } catch (IOException e) { e.printStackTrace(listener.error(Messages.IvyModuleSetBuild_FailedToParseIvyXml())); return Result.FAILURE; } catch (RunnerAbortedException e) { return Result.FAILURE; } catch (RuntimeException e) { // bug in the code. e.printStackTrace( listener.error( "Processing failed due to a bug in the code. Please report this to [email protected]")); logger.println("project=" + project); logger.println("project.getModules()=" + project.getModules()); throw e; } }
private static ParametersAction mergeParameters(ParametersAction base, ParametersAction overlay) { LinkedHashMap<String, ParameterValue> params = new LinkedHashMap<String, ParameterValue>(); for (ParameterValue param : base.getParameters()) params.put(param.getName(), param); for (ParameterValue param : overlay.getParameters()) params.put(param.getName(), param); return new ParametersAction(params.values().toArray(new ParameterValue[params.size()])); }
private boolean isPullRequestBuild(AbstractBuild build, String pullRequestUrl) { ParametersAction parameters = build.getAction(ParametersAction.class); return parameters != null && parameters.getParameters().contains(new StringParameterValue("PR_URL", pullRequestUrl)); }