public EnvironmentVariablesConfig getSecureVariables() { EnvironmentVariablesConfig result = new EnvironmentVariablesConfig(); for (EnvironmentVariableConfig environmentVariableConfig : this) { if (environmentVariableConfig.isSecure()) { result.add(environmentVariableConfig); } } return result; }
@Override public EnvironmentVariablesConfig getPlainTextVariables() { return variables.getPlainTextVariables(); }
@Override public EnvironmentVariablesConfig getSecureVariables() { return variables.getSecureVariables(); }
public EnvironmentVariablesConfig overrideWith(EnvironmentVariablesConfig environmentVariablesConfig) { EnvironmentVariablesConfig variablesConfig = new EnvironmentVariablesConfig(); variablesConfig.addAll(this); for (EnvironmentVariableConfig environmentVariableConfig : environmentVariablesConfig) { variablesConfig.removeIfExists(environmentVariableConfig.getName()); variablesConfig.add(environmentVariableConfig); } return variablesConfig; }
@Override public EnvironmentVariablesConfig getPlainTextVariables() { EnvironmentVariablesConfig allVariables = new EnvironmentVariablesConfig(); for (EnvironmentConfig part : this) { for (EnvironmentVariableConfig partVariable : part.getPlainTextVariables()) { if (!allVariables.contains(partVariable)) allVariables.add(partVariable); } } return allVariables; }
@Test public void shouldPopulateErrorWhenVariableNameStartsWithSpace() { environmentVariablesConfig = new EnvironmentVariablesConfig(); EnvironmentVariableConfig one = new EnvironmentVariableConfig(" foo", "BAR"); environmentVariablesConfig.add(one); environmentVariablesConfig.validate(context); assertThat(one.errors().isEmpty(), is(false)); assertThat(one.errors().on(EnvironmentVariableConfig.NAME), contains("Environment Variable cannot start or end with spaces for pipeline 'some-pipeline'.")); }
@Test public void shouldSetEnvironmentVariablesOnSchedulingContext() throws Exception { EnvironmentVariablesConfig existing = new EnvironmentVariablesConfig(); existing.add("firstVar", "firstVal"); existing.add("overriddenVar", "originalVal"); SchedulingContext schedulingContext = new DefaultSchedulingContext(); schedulingContext = schedulingContext.overrideEnvironmentVariables(existing); EnvironmentVariablesConfig stageLevel = new EnvironmentVariablesConfig(); stageLevel.add("stageVar", "stageVal"); stageLevel.add("overriddenVar", "overriddenVal"); StageConfig config = StageConfigMother.custom("test", Approval.automaticApproval()); config.setVariables(stageLevel); ReflectionUtil.setField(schedulingContext, "rerun", true); SchedulingContext context = schedulingContext.overrideEnvironmentVariables(config.getVariables()); assertThat(context.isRerun(), is(true)); EnvironmentVariablesConfig environmentVariablesUsed = context.getEnvironmentVariablesConfig(); assertThat(environmentVariablesUsed.size(), is(3)); assertThat(environmentVariablesUsed, hasItem(new EnvironmentVariableConfig("firstVar", "firstVal"))); assertThat(environmentVariablesUsed, hasItem(new EnvironmentVariableConfig("overriddenVar", "overriddenVal"))); assertThat(environmentVariablesUsed, hasItem(new EnvironmentVariableConfig("stageVar", "stageVal"))); }
@Test public void shouldClearEnvironmentVariablesWhenTheMapIsNull() { environmentVariablesConfig = new EnvironmentVariablesConfig(); EnvironmentVariableConfig one = new EnvironmentVariableConfig("FOO", "BAR"); environmentVariablesConfig.add(one); environmentVariablesConfig.setConfigAttributes(null); assertThat(environmentVariablesConfig.size(), is(0)); }
@Override public void addEnvironmentVariable(EnvironmentVariableConfig variableConfig) { variables.add(variableConfig); }
private void validateDuplicateEnvironmentVariables(ValidationContext validationContext) { EnvironmentVariablesConfig allVariables = new EnvironmentVariablesConfig(); for (EnvironmentConfig part : this) { for (EnvironmentVariableConfig partVariable : part.getVariables()) { if (!allVariables.hasVariable(partVariable.getName())) { allVariables.add(partVariable); } else { //then it must be equal if (!allVariables.contains(partVariable)) configErrors.add(CONSISTENT_KV, String.format( "Environment variable '%s' is defined more than once with different values", partVariable.getName())); } } } }
public static StageConfig stageConfigWithParams(String stageName, String paramName) { StageConfig stageConfig = StageConfigMother.stageConfig(stageName); ArrayList<EnvironmentVariableConfig> environmentVariableConfigs = new ArrayList<>(); environmentVariableConfigs.add(new EnvironmentVariableConfig("env1", "#{" + paramName + "}")); stageConfig.setVariables(new EnvironmentVariablesConfig(environmentVariableConfigs)); stageConfig.getJobs().add(JobConfigMother.jobConfig()); return stageConfig; }
@Test public void shouldValidateTree() { environmentVariablesConfig = new EnvironmentVariablesConfig(); EnvironmentVariableConfig one = new EnvironmentVariableConfig("FOO", "BAR"); EnvironmentVariableConfig two = new EnvironmentVariableConfig("FOO", "bAZ"); EnvironmentVariableConfig three = new EnvironmentVariableConfig("", "bAZ"); environmentVariablesConfig.add(one); environmentVariablesConfig.add(two); environmentVariablesConfig.add(three); environmentVariablesConfig.validateTree(PipelineConfigSaveValidationContext.forChain(true, "group", new PipelineConfig(new CaseInsensitiveString("p1"), null))); assertThat(one.errors().isEmpty(), is(false)); assertThat(one.errors().firstError(), contains("Environment Variable name 'FOO' is not unique for pipeline 'p1'")); assertThat(two.errors().isEmpty(), is(false)); assertThat(two.errors().firstError(), contains("Environment Variable name 'FOO' is not unique for pipeline 'p1'")); assertThat(three.errors().isEmpty(), is(false)); assertThat(three.errors().firstError(), contains("Environment Variable cannot have an empty name for pipeline 'p1'.")); }
@Test public void shouldCloneStagesSoThatMutationDoesnotAffectTemplate() throws Exception { PipelineConfig pipelineConfig = new PipelineConfig(new CaseInsensitiveString("pipelineName"), new MaterialConfigs(MaterialConfigsMother.hgMaterialConfig("http://google.com"))); pipelineConfig.setTemplateName(new CaseInsensitiveString("templateName")); PipelineTemplateConfig template = new PipelineTemplateConfig(); JobConfig jobConfigFromTemplate = new JobConfig("job-1"); StageConfig stageConfigFromTemplate = new StageConfig(new CaseInsensitiveString("stage-1"), new JobConfigs(jobConfigFromTemplate)); template.add(stageConfigFromTemplate); pipelineConfig.usingTemplate(template); StageConfig stageConfigFromPipeline = pipelineConfig.get(0); EnvironmentVariablesConfig variablesConfig = new EnvironmentVariablesConfig(); variablesConfig.add("FOO", "BAR"); stageConfigFromPipeline.setVariables(variablesConfig); JobConfig jobConfigFromPipeline = stageConfigFromPipeline.jobConfigByConfigName(new CaseInsensitiveString("job-1")); EnvironmentVariablesConfig jobVariablesConfigFromPipeline = new EnvironmentVariablesConfig(); jobVariablesConfigFromPipeline.add("BAZ", "QUUX"); jobConfigFromPipeline.setVariables(jobVariablesConfigFromPipeline); assertThat(stageConfigFromPipeline.getVariables().isEmpty(), is(false)); assertThat(jobConfigFromPipeline.getVariables().isEmpty(), is(false)); assertThat(stageConfigFromTemplate.getVariables().isEmpty(), is(true)); assertThat(jobConfigFromTemplate.getVariables().isEmpty(), is(true)); }
@Test public void shouldSetConfigAttributesSecurely(){ environmentVariablesConfig = new EnvironmentVariablesConfig(); ArrayList<Map<String,String>> attribs = new ArrayList<>(); Map<String,String> var1 = new HashMap<>(); var1.put(EnvironmentVariableConfig.NAME, "name-var1"); var1.put(EnvironmentVariableConfig.VALUE, "val-var1"); attribs.add(var1); Map<String,String> var2 = new HashMap<>(); var2.put(EnvironmentVariableConfig.NAME, "name-var2"); var2.put(EnvironmentVariableConfig.VALUE, "val-var2"); var2.put(EnvironmentVariableConfig.SECURE, "true"); var2.put(EnvironmentVariableConfig.ISCHANGED, "true"); attribs.add(var2); assertThat(environmentVariablesConfig.size(), is(0)); environmentVariablesConfig.setConfigAttributes(attribs); assertThat(environmentVariablesConfig.size(), is(2)); assertThat(environmentVariablesConfig, hasItem(new EnvironmentVariableConfig(null, "name-var1", "val-var1", false))); assertThat(environmentVariablesConfig, hasItem(new EnvironmentVariableConfig(new GoCipher(), "name-var2", "val-var2", true))); }
public SchedulingContext rerunContext() { DefaultSchedulingContext context = new DefaultSchedulingContext(approvedBy, agents, profiles); context.variables = variables.overrideWith(new EnvironmentVariablesConfig()); context.rerun = true; return context; }
@Test public void shouldGetOnlyPlainTextVariables() throws CryptoException { EnvironmentVariablesConfig environmentVariablesConfig = new EnvironmentVariablesConfig(); EnvironmentVariableConfig plainVar1 = new EnvironmentVariableConfig("var1", "var1_value"); EnvironmentVariableConfig plainVar2 = new EnvironmentVariableConfig("var2", "var2_value"); EnvironmentVariableConfig var1 = secureVariable(goCipher, "foo1", "bar1", "encryptedBar1"); EnvironmentVariableConfig var2 = secureVariable(goCipher, "foo2", "bar2", "encryptedBar2"); environmentVariablesConfig.addAll(Arrays.asList(var1, var2, plainVar1, plainVar2)); List<EnvironmentVariableConfig> variables = environmentVariablesConfig.getPlainTextVariables(); assertThat(variables.size(), is(2)); assertThat(variables, hasItems(plainVar1, plainVar2)); }
@Test public void shouldGetSecureVariables() throws CryptoException { EnvironmentVariablesConfig environmentVariablesConfig = new EnvironmentVariablesConfig(); GoCipher mockGoCipher = mock(GoCipher.class); EnvironmentVariableConfig plainVar1 = new EnvironmentVariableConfig("var1", "var1_value"); EnvironmentVariableConfig var1 = secureVariable(mockGoCipher, "foo1", "bar1", "encryptedBar1"); EnvironmentVariableConfig var2 = secureVariable(mockGoCipher, "foo2", "bar2", "encryptedBar2"); EnvironmentVariableConfig var3 = secureVariable(mockGoCipher, "foo3", "bar3", "encryptedBar3"); environmentVariablesConfig.addAll(Arrays.asList(var1, var2, var3, plainVar1)); List<EnvironmentVariableConfig> variables = environmentVariablesConfig.getSecureVariables(); assertThat(variables.size(), is(3)); assertThat(variables, hasItems(var1, var2, var3)); }
@Test public void shouldCopyErrorsForFieldsOnPipelineConfig(){ PipelineConfig pipelineConfig = PipelineConfigMother.pipelineConfig("pipeline", MaterialConfigsMother.defaultMaterialConfigs(), new JobConfigs(JobConfigMother.createJobConfigWithJobNameAndEmptyResources())); pipelineConfig.setVariables(new EnvironmentVariablesConfig(asList(new EnvironmentVariableConfig("name", "value")))); PipelineConfig pipelineWithErrors = new Cloner().deepClone(pipelineConfig); pipelineWithErrors.getVariables().get(0).addError("name", "error on environment variable"); pipelineWithErrors.first().addError("name", "error on stage"); pipelineWithErrors.first().getJobs().first().addError("name", "error on job"); BasicCruiseConfig.copyErrors(pipelineWithErrors, pipelineConfig); assertThat(pipelineConfig.getVariables().get(0).errors().on("name"), is("error on environment variable")); assertThat(pipelineConfig.first().errors().on("name"), is("error on stage")); assertThat(pipelineConfig.first().getJobs().first().errors().on("name"), is("error on job")); }
public boolean validateTree(ValidationContext validationContext) { validate(validationContext); boolean isValid = errors.isEmpty(); ValidationContext contextForChildren = validationContext.withParent(this); isValid = jobConfigs.validateTree(contextForChildren) && isValid; isValid = approval.validateTree(contextForChildren) && isValid; isValid = variables.validateTree(contextForChildren) && isValid; return isValid; }
public void setConfigAttributes(Object attributes) { this.clear(); if (attributes != null) { for (Map attributeMap : (List<Map>) attributes) { EnvironmentVariableConfig environmentVariableConfig = new EnvironmentVariableConfig(new GoCipher()); try { environmentVariableConfig.setConfigAttributes(attributeMap); this.add(environmentVariableConfig); } catch (IllegalArgumentException e) { continue; } } } }