Java ParameterValue类代码示例

import hudson.model.ParameterValue; //导入依赖的package包/类
/**
 * @see jenkins.model.ParameterizedJobMixIn#getDefaultParametersValues()
 */
public static List<ParameterValue> getDefaultParametersValues(Job<?, ?> job) {
    ParametersDefinitionProperty paramDefProp = job.getProperty(ParametersDefinitionProperty.class);
    List<ParameterValue> defValues = new ArrayList<>();

    /*
    * This check is made ONLY if someone will call this method even if isParametrized() is false.
    */
    if (paramDefProp == null) {
        return defValues;
    }

    /* Scan for all parameter with an associated default values */
    for (ParameterDefinition paramDefinition : paramDefProp.getParameterDefinitions()) {
        ParameterValue defaultValue = paramDefinition.getDefaultParameterValue();

        if (defaultValue != null) {
            defValues.add(defaultValue);
        }
    }

    return defValues;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
private List<ParameterValue> getParametersValues(final Job job, final String branch) {
    final ParametersDefinitionProperty paramDefProp = (ParametersDefinitionProperty) job.getProperty(ParametersDefinitionProperty.class);
    final ArrayList<ParameterValue> defValues = new ArrayList<>();

    for (final ParameterDefinition paramDefinition : paramDefProp.getParameterDefinitions()) {
        if ("BRANCH".equals(paramDefinition.getName())) {
            final StringParameterValue branchParam = new StringParameterValue("BRANCH", branch);
            defValues.add(branchParam);
        } else {
            final ParameterValue defaultValue = paramDefinition.getDefaultParameterValue();
            if (defaultValue != null)
                defValues.add(defaultValue);
        }
    }

    return defValues;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
@Test
public void customWorkspaceUsingPathParameter() throws Exception {
    WorkflowJob job = j.jenkins.createProject(WorkflowJob.class, RandomStringUtils.randomAlphanumeric(7));
    job.setDefinition(new CpsFlowDefinition(format("" +
            "def customPath = \"${env.JOB_NAME}/${PR_BUILD_NUMBER}/${env.BUILD_NUMBER}\" \n" +
            "def extWorkspace = exwsAllocate diskPoolId: '%s', path: customPath \n" +
            "node { \n" +
            "   exws (extWorkspace) { \n" +
            "       writeFile file: 'foobar.txt', text: 'foobar' \n" +
            "   } \n" +
            "} \n", DISK_POOL_ID)));

    String prBuildNumberValue = "22";
    ParameterValue parameterValue = new StringParameterValue("PR_BUILD_NUMBER", prBuildNumberValue);
    ParametersAction parameterValues = new ParametersAction(parameterValue);

    WorkflowRun run = j.assertBuildStatusSuccess(job.scheduleBuild2(0, parameterValues));
    verifyWorkspacePath(format("%s/%s/%d", job.getFullName(), prBuildNumberValue, run.getNumber()), run);
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
/**
 * Constructs the environment variables for the current build.
 *
 * @return the current build environment variables
 * @throws IOException
 * @throws InterruptedException
 */
private EnvVars constructEnvVars() throws IOException, InterruptedException {
    EnvVars envVars = build.getEnvironment(listener);
    if (build instanceof AbstractBuild) {
        envVars.putAll(((AbstractBuild<?, ?>) build).getBuildVariables()); // Add in matrix axes..
    } else {
        // 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, JENKINS-30357 for details.
        for (ParametersAction pa : build.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(build, envVars);
            }
        }
    }

    return envVars;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
public static List<Action> setJobRunParamsFromEnvAndUIParams(WorkflowJob job, JenkinsPipelineBuildStrategy strat,
		List<Action> buildActions, ParametersAction params) {
	List<EnvVar> envs = strat.getEnv();
	List<ParameterValue> envVarList = new ArrayList<ParameterValue>();
	if (envs.size() > 0) {
		// build list of env var keys for compare with existing job params
		for (EnvVar env : envs) {
			envVarList.add(new StringParameterValue(env.getName(), env.getValue()));
		}
	}

	if (params != null)
		envVarList.addAll(params.getParameters());

	if (envVarList.size() > 0)
		buildActions.add(new ParametersAction(envVarList));

	return buildActions;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
@Override
public ParameterValue createValue(StaplerRequest req) {
    String[] value = req.getParameterValues(getName());
    if (value == null) {
        return getDefaultParameterValue();
    } else if (value.length != 1) {
        throw new IllegalArgumentException(String.format(
                "Illegal number of parameter values for %s: %d",
                getName(),
                value.length));
    } else {
        List<String> choices = getChoices();
        if (choices.contains(value[0])) {
            return new StringParameterValue(getName(), value[0], getDescription());
        } else {
            throw new IllegalArgumentException(String.format(
                    "Value %s for parameter %s is not a valid choice.",
                    value[0],
                    getName()));
        }
    }
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
public static Map<String, Object> getBuildParameters(Run build) {
    List<ParametersAction> actions = build.getActions(ParametersAction.class);
    if (actions != null) {
        Map<String, Object> answer = new HashMap<String, Object>();
        for (ParametersAction action : actions) {
            List<ParameterValue> parameters = action.getParameters();
            if (parameters != null) {
                for (ParameterValue parameter : parameters) {
                    String name = parameter.getName();
                    Object value = parameter.getValue();
                    answer.put(name, value);
                }
            }
        }
        return answer;
    }
    return null;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
public static Object buildParameterOrNull(TaskListener listener, FlowExecution flowExecution, String parameter, String defaultValue) throws IOException {
    if (Strings.isNullOrBlank(parameter)) {
        log(listener, "No parameter name!");
    } else {
        Run<?, ?> run = $build(flowExecution);
        ParametersAction action = null;
        if (run != null) {
            action = run.getAction(ParametersAction.class);
        } else {
            log(listener, "No $build could be found from flowExecution " + flowExecution);
        }
        if (action == null) {
            log(listener, "No ParametersAction could be found!");
        } else {
            ParameterValue parameterValue = action.getParameter(parameter);
            if (parameterValue == null) {
                log(listener, "No ParameterValue could be found for '" + parameter + "'");
            } else {
                return parameterValue.getValue();
            }
        }
    }
    return defaultValue;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
@Override
public Set<ParameterValue> getRunParameters() {
    Set<ParameterValue> parameters = new HashSet<ParameterValue>();
    parameters.add(new StringParameterValue(KEY_REPO_NAME, getRepoName()));
    String host = getRegistryHost();
    if (!StringUtils.isBlank(host)) {
        parameters.add(new StringParameterValue(KEY_DOCKER_HUB_HOST, host));
    }
    String tag = getTag();
    if (!StringUtils.isBlank(tag)) {
        parameters.add(new StringParameterValue(KEY_TAG, tag));
    }
    String pusher = getPusher();
    if (!StringUtils.isBlank(pusher)) {
        parameters.add(new StringParameterValue(KEY_PUSHER, pusher));
    }
    return parameters;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
private DeployJobVariables extractDeployJobVariables(AbstractBuild build) {
    String environment = DeployJobVariablesBuilder.UNDEFINED;
    String version = DeployJobVariablesBuilder.UNDEFINED;
    List<ParametersAction> actionList = Util.filter(build.getAllActions(), ParametersAction.class);
    for (ParametersAction parametersAction : actionList) {
        List<ParameterValue> params = parametersAction.getParameters();
        for (ParameterValue parameterValue : params) {
            if (DashboardView.PARAM_ENVIRONMENT.equalsIgnoreCase((String) parameterValue.getName())) {
                environment = (String) parameterValue.getValue();
            }
            if (DashboardView.PARAM_VERSION.equalsIgnoreCase((String) parameterValue.getName())) {
                version = (String) parameterValue.getValue();
            }
        }
    }
    return DeployJobVariablesBuilder.createBuilder().version(version).environment(environment).build();
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
/**
 * this method started out as hudson.model.AbstractProject.getDefaultParametersValues()
 * @param parameterValues 
 * @return the ParameterValues as set from the crontab row or their defaults
 */
@SuppressWarnings("unchecked")
private List<ParameterValue> configurePropertyValues(Map<String, String> parameterValues) {
	assert job != null : "job must not be null if this was 'started'";
	ParametersDefinitionProperty paramDefProp = (ParametersDefinitionProperty) job
			.getProperty(ParametersDefinitionProperty.class);
	ArrayList<ParameterValue> defValues = new ArrayList<ParameterValue>();

	/* Scan for all parameter with an associated default values */
	for (ParameterDefinition paramDefinition : paramDefProp.getParameterDefinitions()) {
		ParameterValue defaultValue = paramDefinition.getDefaultParameterValue();

		if (parameterValues.containsKey(paramDefinition.getName())) {
			ParameterizedStaplerRequest request = new ParameterizedStaplerRequest(
					parameterValues.get(paramDefinition.getName()));
			defValues.add(paramDefinition.createValue(request));
		} else if (defaultValue != null)
			defValues.add(defaultValue);
	}

	return defValues;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
/** Get the default parameter values for the given delegate */
private ParametersAction getDefaultParametersValues(
    AbstractProject delegate) {
  final ParametersDefinitionProperty property =
      (ParametersDefinitionProperty) delegate.getProperty(
          ParametersDefinitionProperty.class);
  if (property == null) {
    return null;
  }

  final List<ParameterValue> result = Lists.newArrayList();
  for (ParameterDefinition def : property.getParameterDefinitions()) {
    ParameterValue value = def.getDefaultParameterValue();
    if (value != null) {
      result.add(value);
    }
  }

  return new ParametersAction(result);
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
/**
 * Find the previous BuildData for the given pull request number; this may return null
 */
private BuildData findPreviousBuildForPullId(StringParameterValue pullIdPv) {
	// find the previous build for this particular pull requet, it may not be the last build
	for (Run<?,?> r : job.getBuilds()) {
		ParametersAction pa = r.getAction(ParametersAction.class);
		if (pa != null) {
			for (ParameterValue pv : pa.getParameters()) {
				if (pv.equals(pullIdPv)) {
					for (BuildData bd : r.getActions(BuildData.class)) {
						return bd;
					}
				}
			}
		}
	}
	return null;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
/**
 * It extracts and removes internal parameters from the full list of parameters as they need to be managed
 * in a special way for security reasons (related to SECURITY-170).
 *
 * @param values internal parameters values (internal parameters are defined in {@link #getParameterDefinitions()}
 * @return internal parameters values
 */
private List<ParameterValue> extractAndRemoveInternalParameters(List<ParameterValue> values) {
	List<ParameterValue> internal = new ArrayList<ParameterValue>();
	List<ParameterDefinition> parameterDefinitions = getParameterDefinitions();
	Iterator<ParameterValue> it = values.iterator();
	while (it.hasNext()) {
		ParameterValue next = it.next();
		for (ParameterDefinition pd : parameterDefinitions) {
			if (next.getName().equals(pd.getName())) {
				internal.add(next);
				it.remove();
				break;
			}
		}
	}
	return internal;
}
 

import hudson.model.ParameterValue; //导入依赖的package包/类
@Test
public void testCreateValue() {
    GroovyScript script = new GroovyScript(new SecureGroovyScript(SCRIPT, Boolean.FALSE, null),
            new SecureGroovyScript(FALLBACK_SCRIPT, Boolean.FALSE, null));
    ChoiceParameter param = new ChoiceParameter("name", "description", "some-random-name", script, "choiceType",
            true, 0);
    ParameterValue value = param.createValue("value");

    assertEquals("value", value.getValue().toString());

    JSONObject json = new JSONObject();
    json.put("name", "name");
    json.put("value", "value");

    StaplerRequest request = PowerMockito.mock(StaplerRequest.class);
    PowerMockito.when(request.bindJSON(StringParameterValue.class, json)).thenReturn((StringParameterValue) value);

    value = param.createValue(request, json);

    assertEquals("value", value.getValue().toString());
}