Refine search
String v = p.createVariableResolver(this).resolve(p.getName()); if (v!=null) r.put(p.getName(),v);
private boolean fitsSearchBuildParameters(ParametersAction parametersAction) { List<ParameterValue> parameters = parametersAction.getParameters(); for (ParameterValue parameter : parameters) { if (!parameter.isSensitive() && fitsSearchString(parameter.getValue())) { return true; } } return false; } }
@Override public void buildEnvironment(Run<?,?> run, EnvVars env) { for (ParameterValue p : getParameters()) { if (p == null) continue; p.buildEnvironment(run, env); } }
/** @deprecated Use {@link #buildEnvironment(Run, EnvVars)} instead. */ @Deprecated public void buildEnvVars(AbstractBuild<?,?> build, EnvVars env) { if (Util.isOverridden(ParameterValue.class, getClass(), "buildEnvironment", Run.class, EnvVars.class)) { buildEnvironment(build, env); } else { // for backward compatibility buildEnvVars(build,(Map<String,String>)env); } }
/** * Builds up a set of variable names that contain sensitive values that * should not be exposed. The expectation is that this set is populated with * keys returned by {@link #getBuildVariables()} that should have their * values masked for display purposes. * * @since 1.378 */ public Set<String> getSensitiveBuildVariables() { Set<String> s = new HashSet<String>(); ParametersAction parameters = getAction(ParametersAction.class); if (parameters != null) { for (ParameterValue p : parameters) { if (p.isSensitive()) { s.add(p.getName()); } } } // Allow BuildWrappers to determine if any of their data is sensitive if (project instanceof BuildableItemWithBuildWrappers) { for (BuildWrapper bw : ((BuildableItemWithBuildWrappers) project).getBuildWrappersList()) { bw.makeSensitiveBuildVariables(this, s); } } return s; }
public 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()])); }
/** * Creates a new {@link ParametersAction} that contains all the parameters in this action * with the overrides / new values given as parameters. * @return New {@link ParametersAction}. The result may contain null {@link ParameterValue}s */ @Nonnull public ParametersAction createUpdated(Collection<? extends ParameterValue> overrides) { if(overrides == null) { ParametersAction parametersAction = new ParametersAction(parameters); parametersAction.safeParameters = this.safeParameters; return parametersAction; } List<ParameterValue> combinedParameters = Lists.<ParameterValue>newArrayList(overrides); Set<String> names = newHashSet(); for(ParameterValue v : overrides) { if (v == null) continue; names.add(v.getName()); } for (ParameterValue v : parameters) { if (v == null) continue; if (!names.contains(v.getName())) { combinedParameters.add(v); } } return new ParametersAction(combinedParameters, this.safeParameters); }
@Override public void buildEnvironmentFor(@Nonnull Run r, @Nonnull EnvVars envs, @Nonnull TaskListener listener) throws IOException, InterruptedException { if (r instanceof MatrixRun) { MatrixChildParametersAction childParameters = r.getAction(MatrixChildParametersAction.class); if (childParameters != null) { for(ParameterValue p : childParameters.getParameters()) { putEnvVar(envs, p.getName(), String.valueOf(p.getValue())); } } } }
/** * Gets a human-readable message about the parameters of this item * @return String */ @Exported public String getParams() { StringBuilder s = new StringBuilder(); for (ParametersAction pa : getActions(ParametersAction.class)) { for (ParameterValue p : pa.getParameters()) { s.append('\n').append(p.getShortDescription()); } } return s.toString(); }
public ParameterValue getParameter(String name) { for (ParameterValue p : parameters) { if (p == null) continue; if (p.getName().equals(name)) return p; } return null; }
protected Collection<ParameterValue> getParameterValues() { Map<String, ParameterValue> map = new HashMap<String, ParameterValue>(); Run<?,?> run = this.getBuild(); List<ParametersAction> actions = run.getActions(ParametersAction.class); for (ParametersAction pa : actions) { for (ParameterValue pv : pa.getParameters()) { if (pv == null || pv.getName() == null) { continue; } map.put(pv.getName(), pv); } } return map.values(); } }
private String getSourceBuildNumber(DynamicBuild dynamicBuild) { if (dynamicBuild.getCause() instanceof DotCiUpstreamTriggerCause) { List<ParameterValue> params = dynamicBuild.getAction(ParametersAction.class).getParameters(); for (ParameterValue param : params) { if (param.getName().equals("SOURCE_BUILD")) { return (String) param.getValue(); } } } return "" + dynamicBuild.getNumber(); }
/** * Creates an {@link VariableResolver} that aggregates all the parameters. * * <p> * If you are a {@link BuildStep}, most likely you should call {@link AbstractBuild#getBuildVariableResolver()}. */ public VariableResolver<String> createVariableResolver(AbstractBuild<?,?> build) { VariableResolver[] resolvers = new VariableResolver[getParameters().size()+1]; int i=0; for (ParameterValue p : getParameters()) { if (p == null) continue; resolvers[i++] = p.createVariableResolver(build); } resolvers[i] = build.getBuildVariableResolver(); return new VariableResolver.Union<String>(resolvers); }
public static EnvVars extractBuildParameters(Run build, TaskListener listener) { EnvVars buildVariables = new EnvVars(); try { ParametersAction parameters = build.getAction(ParametersAction.class); if (parameters != null) { for (ParameterValue p : parameters) { if (p.isSensitive()) { continue; } String v = p.createVariableResolver(null).resolve(p.getName()); if (v != null) { buildVariables.put(p.getName(), v); } } } } catch (Exception e) { listener.getLogger().println("Can't get build variables"); return null; } return buildVariables; }
private List<? extends ParameterValue> filter(List<ParameterValue> parameters) { if (this.run == null) { return parameters; } if (this.parameterDefinitionNames == null) { return parameters; } Boolean shouldKeepFlag = SystemProperties.optBoolean(KEEP_UNDEFINED_PARAMETERS_SYSTEM_PROPERTY_NAME); if (shouldKeepFlag != null && shouldKeepFlag.booleanValue()) { return parameters; } List<ParameterValue> filteredParameters = new ArrayList<ParameterValue>(); for (ParameterValue v : this.parameters) { if (this.parameterDefinitionNames.contains(v.getName()) || isSafeParameter(v.getName())) { filteredParameters.add(v); } else if (shouldKeepFlag == null) { LOGGER.log(Level.WARNING, "Skipped parameter `{0}` as it is undefined on `{1}`. Set `-D{2}=true` to allow " + "undefined parameters to be injected as environment variables or `-D{3}=[comma-separated list]` to whitelist specific parameter names, " + "even though it represents a security breach or `-D{2}=false` to no longer show this message.", new Object [] { v.getName(), run.getParent().getFullName(), KEEP_UNDEFINED_PARAMETERS_SYSTEM_PROPERTY_NAME, SAFE_PARAMETERS_SYSTEM_PROPERTY_NAME }); } } return filteredParameters; }
private Boolean matchRule(Job job, Run run, String rule) { if (rule == null) { return true; } // 1. try to match ${params.xxx=yyy} Matcher matcher = paramsPattern.matcher(rule); if (matcher.find()) { String paramName = matcher.group(1); String paramValue = matcher.group(2); ParametersAction params = run.getAction(ParametersAction.class); if (params != null) { ParameterValue value = params.getParameter(paramName); if (value != null && value.getValue().toString().equals(paramValue)) { return true; } } } return false; }
private static String getStringValue( final Map<String, String> resolvedVariables, final String param, final ParameterValue defaultParameterValue) { if (!isNullOrEmpty(resolvedVariables.get(param))) { return resolvedVariables.get(param); } if (defaultParameterValue.getValue() == null) { return ""; } return defaultParameterValue.getValue().toString(); } }
@Override public int hashCode() { int result = super.hashCode(); result = 31 * result + (value ? 1 : 0); return result; }
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; if (!super.equals(o)) return false; BooleanParameterValue that = (BooleanParameterValue) o; if (value != that.value) return false; return true; }
/** * Creates an {@link VariableResolver} that aggregates all the parameters. * * <p> * If you are a {@link BuildStep}, most likely you should call {@link AbstractBuild#getBuildVariableResolver()}. */ public VariableResolver<String> createVariableResolver(AbstractBuild<?,?> build) { VariableResolver[] resolvers = new VariableResolver[parameters.size()+1]; int i=0; for (ParameterValue p : parameters) resolvers[i++] = p.createVariableResolver(build); resolvers[i] = build.getBuildVariableResolver(); return new VariableResolver.Union<String>(resolvers); }