public File[] getFiles(File configRepoCheckoutDirectory, PartialConfigLoadContext context) { String pattern = defaultPattern; Configuration configuration = context.configuration(); if (configuration != null) { ConfigurationProperty explicitPattern = configuration.getProperty("pattern"); if (explicitPattern != null) { pattern = explicitPattern.getValue(); } } return getFiles(configRepoCheckoutDirectory, pattern); }
protected void setPluginConfigurationAttributes(Map attributes) { SCMConfigurations scmConfigurations = SCMMetadataStore.getInstance().getConfigurationMetadata(pluginConfiguration.getId()); if (scmConfigurations == null) { throw new RuntimeException("metadata unavailable for plugin: " + pluginConfiguration.getId()); } for (SCMConfiguration scmConfiguration : scmConfigurations.list()) { String key = scmConfiguration.getKey(); if (attributes.containsKey(key)) { if (configuration.getProperty(key) == null) { configuration.addNewConfiguration(scmConfiguration.getKey(), scmConfiguration.getOption(Property.SECURE)); } configuration.getProperty(key).setConfigurationValue(new ConfigurationValue((String) attributes.get(key))); configuration.getProperty(key).handleSecureValueConfiguration(scmConfiguration.getOption(Property.SECURE)); } } }
@Override protected void setTaskConfigAttributes(Map attributes) { TaskConfig taskConfig = PluggableTaskConfigStore.store().preferenceFor(pluginConfiguration.getId()).getConfig(); for (Property property : taskConfig.list()) { String key = property.getKey(); if (attributes.containsKey(key)) { Boolean isSecure = property.getOption(Property.SECURE); if (configuration.getProperty(key) == null) { configuration.addNewConfiguration(property.getKey(), isSecure); } configuration.getProperty(key).setConfigurationValue(new ConfigurationValue((String) attributes.get(key))); configuration.getProperty(key).handleSecureValueConfiguration(isSecure); } } }
private void assertConfigProperty(Configuration configuration, String name, String plainTextValue, boolean shouldBeEncrypted) { assertThat(configuration.getProperty(name).getValue(), is(plainTextValue)); if (shouldBeEncrypted) { assertThat(configuration.getProperty(name).getEncryptedValue(), startsWith("AES")); } else { assertThat(configuration.getProperty(name).getEncryptedValue(), is(nullValue())); } } private void assertXsdFailureDuringLoad(String configXML, String... expectedMessages) {
@Test public void shouldGetNullIfPropertyNotFoundForGivenKey() { Configuration config = new Configuration(); assertThat(config.getProperty("key2"), is(nullValue())); }
private void addErrorsToConfiguration(ValidationResult validationResult, PackageRepository packageRepository) { for (ValidationError validationError : validationResult.getErrors()) { ConfigurationProperty property = packageRepository.getConfiguration().getProperty(validationError.getKey()); if (property != null) { property.addError(validationError.getKey(), validationError.getMessage()); } else { String validationErrorKey = StringUtils.isBlank(validationError.getKey()) ? PackageRepository.CONFIGURATION : validationError.getKey(); packageRepository.addError(validationErrorKey, validationError.getMessage()); } } }
private void addErrorsToConfiguration(ValidationResult validationResult, PackageDefinition packageDefinition) { for (ValidationError validationError : validationResult.getErrors()) { ConfigurationProperty property = packageDefinition.getConfiguration().getProperty(validationError.getKey()); if (property != null) { property.addError(validationError.getKey(), validationError.getMessage()); } else { String validationErrorKey = StringUtils.isBlank(validationError.getKey()) ? PackageDefinition.CONFIGURATION : validationError.getKey(); packageDefinition.addError(validationErrorKey, validationError.getMessage()); } } }
@Override public List<TaskProperty> getPropertiesForDisplay() { ArrayList<TaskProperty> taskProperties = new ArrayList<>(); if (PluggableTaskConfigStore.store().hasPreferenceFor(pluginConfiguration.getId())) { TaskPreference preference = taskPreference(); List<? extends Property> propertyDefinitions = preference.getConfig().list(); for (Property propertyDefinition : propertyDefinitions) { ConfigurationProperty configuredProperty = configuration.getProperty(propertyDefinition.getKey()); if (configuredProperty == null) continue; taskProperties.add(new TaskProperty(propertyDefinition.getOption(Property.DISPLAY_NAME), configuredProperty.getDisplayValue(), configuredProperty.getConfigKeyName())); } return taskProperties; } for (ConfigurationProperty property : configuration) { taskProperties.add(new TaskProperty(property.getConfigKeyName(), property.getDisplayValue())); } return taskProperties; }
@Test public void setConfigAttributes_shouldSetConfigurationAsIsIfPluginIdIsBlank() throws CryptoException { HashMap<Object, Object> imageMap = new HashMap<>(); imageMap.put("value", new GoCipher().encrypt("some-encrypted-value")); imageMap.put("isSecure", "true"); HashMap<Object, Object> tagMap = new HashMap<>(); tagMap.put("value", "18.6.0"); tagMap.put("isSecure", "false"); HashMap<Object, Object> configurationMap1 = new HashMap<>(); configurationMap1.put("Image", imageMap); configurationMap1.put("Tag", tagMap); HashMap<String, Object> artifactPlan1 = new HashMap<>(); artifactPlan1.put("artifactTypeValue", "Pluggable Artifact"); artifactPlan1.put("id", "artifactId"); artifactPlan1.put("storeId", "storeId"); artifactPlan1.put("pluginId", ""); artifactPlan1.put("configuration", configurationMap1); List<Map> artifactPlansList = new ArrayList<>(); artifactPlansList.add(artifactPlan1); ArtifactConfigs artifactConfigs = new ArtifactConfigs(); artifactConfigs.setConfigAttributes(artifactPlansList); assertThat(artifactConfigs.size(), is(1)); PluggableArtifactConfig artifactConfig = (PluggableArtifactConfig) artifactConfigs.get(0); assertThat(artifactConfig.getArtifactType(), is(ArtifactType.external)); assertThat(artifactConfig.getId(), is("artifactId")); assertThat(artifactConfig.getStoreId(), is("storeId")); assertThat(artifactConfig.getConfiguration().getProperty("Image").getValue(), is("some-encrypted-value")); assertThat(artifactConfig.getConfiguration().getProperty("Tag").getValue(), is("18.6.0")); }
private void mapErrorsToConfiguration(ValidationResult result, Configuration configuration, Validatable validatableConfig) { for (ValidationError validationError : result.getErrors()) { ConfigurationProperty property = configuration.getProperty(validationError.getKey()); if (property == null) { validatableConfig.addError(validationError.getKey(), validationError.getMessage()); } else { property.addError(validationError.getKey(), validationError.getMessage()); } } } }
private void mapErrorsToConfiguration(ValidationResult result, PluggableTask task) { for (ValidationError validationError : result.getErrors()) { ConfigurationProperty property = task.getConfiguration().getProperty(validationError.getKey()); if (property != null) { property.addError(validationError.getKey(), validationError.getMessage()); } else { task.addError(validationError.getKey(), validationError.getMessage()); } } } }
private void addErrorsToConfiguration(ValidationResult validationResult, SCM scmConfig) { for (ValidationError validationError : validationResult.getErrors()) { ConfigurationProperty property = scmConfig.getConfiguration().getProperty(validationError.getKey()); if (property != null) { property.addError(validationError.getKey(), validationError.getMessage()); } else { scmConfig.addError(validationError.getKey(), validationError.getMessage()); } } }
@Test public void shouldSetConfigAttributesAsAvailable() throws Exception { SCMConfigurations scmConfigurations = new SCMConfigurations(); scmConfigurations.add(new SCMConfiguration("url")); scmConfigurations.add(new SCMConfiguration("username")); scmConfigurations.add(new SCMConfiguration("password").with(SECURE, true)); SCMMetadataStore.getInstance().addMetadataFor("plugin-id", scmConfigurations, null); Map<String, String> attributeMap = DataStructureUtils.m(SCM.SCM_ID, "scm-id", SCM.NAME, "scm-name", SCM.AUTO_UPDATE, "false", "url", "http://localhost", "username", "user", "password", "pass"); SCM scm = new SCM(null, new PluginConfiguration("plugin-id", "1"), new Configuration()); scm.setConfigAttributes(attributeMap); assertThat(scm.getId(), is("scm-id")); assertThat(scm.getName(), is("scm-name")); assertThat(scm.isAutoUpdate(), is(false)); assertThat(scm.getPluginConfiguration().getId(), is("plugin-id")); assertThat(scm.getConfigAsMap().get("url").get(SCM.VALUE_KEY), is("http://localhost")); assertThat(scm.getConfigAsMap().get("username").get(SCM.VALUE_KEY), is("user")); assertThat(scm.getConfigAsMap().get("password").get(SCM.VALUE_KEY), is("pass")); assertThat(scm.getConfiguration().getProperty("password").getConfigurationValue(), is(nullValue())); assertThat(scm.getConfiguration().getProperty("password").getEncryptedConfigurationValue(), is(not(nullValue()))); }
public void validate(final SCM scmConfig) { final String pluginId = scmConfig.getPluginConfiguration().getId(); final SCMPropertyConfiguration configuration = getScmPropertyConfiguration(scmConfig); ValidationResult validationResult = scmExtension.isSCMConfigurationValid(pluginId, configuration); if (SCMMetadataStore.getInstance().hasPreferenceFor(pluginId)) { SCMConfigurations configurationMetadata = SCMMetadataStore.getInstance().getConfigurationMetadata(pluginId); for (SCMConfiguration scmConfiguration : configurationMetadata.list()) { String key = scmConfiguration.getKey(); boolean isRequired = SCMMetadataStore.getInstance().hasOption(pluginId, key, Property.REQUIRED); ConfigurationProperty property = scmConfig.getConfiguration().getProperty(key); String configValue = property == null ? null : property.getValue(); if (isRequired && StringUtils.isBlank(configValue)) { validationResult.addError(new ValidationError(key, "This field is required")); } } } for (ValidationError validationError : validationResult.getErrors()) { ConfigurationProperty property = scmConfig.getConfiguration().getProperty(validationError.getKey()); if (property != null) { property.addError(validationError.getKey(), validationError.getMessage()); } } }
@Test public void shouldMigrateEncryptedPluginPropertyValueWithNewlineAndSpaces_XslMigrationFrom88To90() throws Exception { resetCipher.setupDESCipherFile(); String plainText = "user-password!"; // "user-password!" encrypted using the above key String encryptedValue = "mvcX9yrQsM4iPgm1tDxN1A=="; String encryptedValueWithWhitespaceAndNewline = new StringBuilder(encryptedValue).insert(2, "\r\n" + " ").toString(); String content = configWithPluggableScm( "<scm id=\"f7c309f5-ea4d-41c5-9c43-95d79fa9ec7b\" name=\"gocd-private\">\n" + " <pluginConfiguration id=\"github.pr\" version=\"1\" />\n" + " <configuration>\n" + " <property>\n" + " <key>plainTextKey</key>\n" + " <value>https://url/some_path</value>\n" + " </property>\n" + " <property>\n" + " <key>secureKey</key>\n" + " <encryptedValue>" + encryptedValueWithWhitespaceAndNewline + "</encryptedValue>\n" + " </property>\n" + " </configuration>\n" + " </scm>", 88); CruiseConfig config = ConfigMigrator.loadWithMigration(content).config; assertThat(config.getSCMs().get(0).getConfiguration().getProperty("secureKey").getValue(), is(plainText)); assertThat(config.getSCMs().get(0).getConfiguration().getProperty("secureKey").getEncryptedValue(), startsWith("AES:")); assertThat(config.getSCMs().get(0).getConfiguration().getProperty("plainTextKey").getValue(), is("https://url/some_path")); }
@Test public void shouldSetConfigAttributes() throws Exception { PackageDefinition definition = new PackageDefinition(); String pluginId = "plugin"; Map config = createPackageDefinitionConfiguration("package-name", pluginId, new ConfigurationHolder("key1", "value1"), new ConfigurationHolder("key2", "value2", "encrypted-value", true, "1"), new ConfigurationHolder("key3", "test", "encrypted-value", true, "0")); PackageConfigurations metadata = new PackageConfigurations(); metadata.addConfiguration(new PackageConfiguration("key1")); metadata.addConfiguration(new PackageConfiguration("key2").with(PackageConfiguration.SECURE, true)); metadata.addConfiguration(new PackageConfiguration("key3").with(PackageConfiguration.SECURE, true)); PackageMetadataStore.getInstance().addMetadataFor(pluginId, metadata); definition.setRepository(PackageRepositoryMother.create("1")); definition.setConfigAttributes(config); String encryptedValue = new GoCipher().encrypt("value2"); assertThat(definition.getName(), is("package-name")); assertThat(definition.getConfiguration().size(), is(3)); assertThat(definition.getConfiguration().getProperty("key1").getConfigurationValue().getValue(), is("value1")); assertThat(definition.getConfiguration().getProperty("key1").getEncryptedConfigurationValue(), is(nullValue())); assertThat(definition.getConfiguration().getProperty("key2").getEncryptedValue(), is(encryptedValue)); assertThat(definition.getConfiguration().getProperty("key2").getConfigurationValue(), is(nullValue())); assertThat(definition.getConfiguration().getProperty("key3").getEncryptedValue(), is("encrypted-value")); assertThat(definition.getConfiguration().getProperty("key3").getConfigurationValue(), is(nullValue())); }
@Test public void shouldLoadConfigWithConfigRepoAndConfiguration() throws Exception { CruiseConfig cruiseConfig = xmlLoader.loadConfigHolder(configWithConfigRepos( " <config-repos>\n" + " <config-repo id=\"id1\" pluginId=\"gocd-xml\">\n" + " <git url=\"https://github.com/tomzo/gocd-indep-config-part.git\" />\n" + " <configuration>\n" + " <property>\n" + " <key>pattern</key>\n" + " <value>*.gocd.xml</value>\n" + " </property>\n" + " </configuration>\n" + " </config-repo >\n" + " </config-repos>\n" )).config; assertThat(cruiseConfig.getConfigRepos().size(), is(1)); ConfigRepoConfig configRepo = cruiseConfig.getConfigRepos().get(0); assertThat(configRepo.getConfiguration().size(), is(1)); assertThat(configRepo.getConfiguration().getProperty("pattern").getValue(), is("*.gocd.xml")); }
@Test public void shouldGetConfigPropertyForGivenKey() { ConfigurationProperty property1 = new ConfigurationProperty(new ConfigurationKey("key1"), new ConfigurationValue("value1"), null, null); ConfigurationProperty property2 = new ConfigurationProperty(new ConfigurationKey("key2"), new ConfigurationValue("value2"), null, null); Configuration config = new Configuration(property1, property2); assertThat(config.getProperty("key2"), is(property2)); }
@Test public void shouldAddPackageDefinitionToGivenRepository() throws Exception { String repoId = "repo-id"; PackageRepository packageRepository = PackageRepositoryMother.create(repoId, "repo-name", "plugin-id", "1.0", new Configuration()); PackageDefinition existing = PackageDefinitionMother.create("pkg-1", "pkg1-name", new Configuration(), packageRepository); packageRepository.setPackages(new Packages(existing)); cruiseConfig.setPackageRepositories(new PackageRepositories(packageRepository)); Configuration configuration = new Configuration(); configuration.add(new ConfigurationProperty(new ConfigurationKey("key"), new ConfigurationValue("value"))); configuration.add(new ConfigurationProperty(new ConfigurationKey("key-with-no-value"), new ConfigurationValue(""))); PackageDefinition packageDefinition = PackageDefinitionMother.create(null, "pkg2-name", configuration, packageRepository); cruiseConfig.savePackageDefinition(packageDefinition); assertThat(cruiseConfig.getPackageRepositories().size(), is(1)); assertThat(cruiseConfig.getPackageRepositories().get(0).getId(), is(repoId)); assertThat(cruiseConfig.getPackageRepositories().get(0).getPackages().size(), is(2)); assertThat(cruiseConfig.getPackageRepositories().get(0).getPackages().get(0).getId(), is(existing.getId())); PackageDefinition createdPkgDef = cruiseConfig.getPackageRepositories().get(0).getPackages().get(1); assertThat(createdPkgDef.getId(), is(notNullValue())); assertThat(createdPkgDef.getConfiguration().getProperty("key"), is(Matchers.notNullValue())); assertThat(createdPkgDef.getConfiguration().getProperty("key-with-no-value"), is(nullValue())); }
public boolean validate(final PluggableTask modifiedTask) { final TaskConfig configuration = new TaskConfig(); for (ConfigurationProperty configurationProperty : modifiedTask.getConfiguration()) { configuration.add(new TaskConfigProperty(configurationProperty.getConfigurationKey().getName(), configurationProperty.getValue())); } final String pluginId = modifiedTask.getPluginConfiguration().getId(); ValidationResult validationResult = taskExtension.validate(pluginId, configuration); final TaskPreference preference = PluggableTaskConfigStore.store().preferenceFor(pluginId); if (PluggableTaskConfigStore.store().hasPreferenceFor(pluginId)) { for (ConfigurationProperty configurationProperty : modifiedTask.getConfiguration()) { String key = configurationProperty.getConfigurationKey().getName(); final Property property = preference.getConfig().get(key); if (property != null) { final Boolean required = property.getOption(Property.REQUIRED); if (required && StringUtils.isBlank(configurationProperty.getConfigValue())) validationResult.addError(new ValidationError(property.getKey(), "This field is required")); } } } for (ValidationError validationError : validationResult.getErrors()) { modifiedTask.getConfiguration().getProperty(validationError.getKey()).addError(validationError.getKey(), validationError.getMessage()); } return validationResult.isSuccessful(); }