private void handlePackageRepositoryProperties(List<String> list) { PackageConfigurations metadata = RepositoryMetadataStore.getInstance().getMetadata(pluginId()); for (ConfigurationProperty configurationProperty : packageRepository.getConfiguration()) { handleProperty(list, metadata, configurationProperty); } }
@Test public void shouldPopulateDataCorrectly() throws Exception { PackageConfigurations repositoryConfigurationPut = new PackageConfigurations(); RepositoryMetadataStore.getInstance().addMetadataFor("plugin-id", repositoryConfigurationPut); assertThat(RepositoryMetadataStore.getInstance().getMetadata("plugin-id"), is(repositoryConfigurationPut)); }
@Test public void shouldGetAllPluginIds() throws Exception { RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance(); metadataStore.addMetadataFor("plugin1", new PackageConfigurations()); metadataStore.addMetadataFor("plugin2", new PackageConfigurations()); metadataStore.addMetadataFor("plugin3", new PackageConfigurations()); assertThat(metadataStore.getPlugins().size(), is(3)); assertThat(metadataStore.getPlugins().contains("plugin1"), is(true)); assertThat(metadataStore.getPlugins().contains("plugin2"), is(true)); assertThat(metadataStore.getPlugins().contains("plugin3"), is(true)); }
public static void clear() { List<String> plugins = RepositoryMetadataStore.getInstance().getPlugins(); for (String pluginId : plugins) { RepositoryMetadataStore.getInstance().removeMetadata(pluginId); PackageMetadataStore.getInstance().removeMetadata(pluginId); } } }
private boolean doesPluginExist() { return packageRepository != null && RepositoryMetadataStore.getInstance().hasPlugin(pluginId()); }
@Test public void shouldReturnSomethingMoreSaneForToString() throws Exception { PackageMaterial material = MaterialsMother.packageMaterial(); RepositoryMetadataStore.getInstance().addMetadataFor(material.getPluginId(), new PackageConfigurations()); PackageMetadataStore.getInstance().addMetadataFor(material.getPluginId(), new PackageConfigurations()); assertThat(material.toString(), is("'PackageMaterial{Repository: [k1=repo-v1, k2=repo-v2] - Package: [k3=package-v1]}'")); }
@Test public void shouldAnswerIfKeyHasGivenOption() throws Exception { PackageConfigurations repositoryConfigurationPut = new PackageConfigurations(); repositoryConfigurationPut.add(new PackageConfiguration("key-one").with(PackageConfiguration.SECURE, true).with(PackageConfiguration.REQUIRED, true)); repositoryConfigurationPut.add(new PackageConfiguration("key-two")); RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance(); metadataStore.addMetadataFor("plugin-id", repositoryConfigurationPut); assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.SECURE),is(true)); assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.REQUIRED),is(true)); assertThat(metadataStore.hasOption("plugin-id", "key-one", PackageConfiguration.PART_OF_IDENTITY),is(true)); assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.SECURE),is(false)); assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.REQUIRED),is(true)); assertThat(metadataStore.hasOption("plugin-id", "key-two", PackageConfiguration.PART_OF_IDENTITY),is(true)); }
@Test public void shouldBeAbleToCheckIfPluginExists() throws Exception { RepositoryMetadataStore metadataStore = RepositoryMetadataStore.getInstance(); PackageConfigurations repositoryConfigurationPut = new PackageConfigurations(); metadataStore.addMetadataFor("plugin-id", repositoryConfigurationPut); assertThat(metadataStore.hasPlugin("plugin-id"), is(true)); assertThat(metadataStore.hasPlugin("some-plugin-which-does-not-exist"), is(false)); } }
@PostConstruct public void applyPackagePluginMetadata() { String pluginId = pluginConfiguration.getId(); for (ConfigurationProperty configurationProperty : configuration) { RepositoryMetadataStore repositoryMetadataStore = RepositoryMetadataStore.getInstance(); if (repositoryMetadataStore.getMetadata(pluginId) != null) { boolean isSecureProperty = repositoryMetadataStore.hasOption(pluginId, configurationProperty.getConfigurationKey().getName(), PackageConfiguration.SECURE); configurationProperty.handleSecureValueConfiguration(isSecureProperty); } } for (PackageDefinition packageDefinition : packages) { packageDefinition.applyPackagePluginMetadata(pluginId); } }
@Before public void setUp() throws Exception { pluginDescriptor = new GoPluginDescriptor("plugin-id", "1.0", null, null, null, true); pluginManager = mock(PluginManager.class); packageRepositoryExtension = mock(PackageRepositoryExtension.class); metadataLoader = new PackageMaterialMetadataLoader(pluginManager, packageRepositoryExtension); RepositoryMetadataStore.getInstance().removeMetadata(pluginDescriptor.id()); PackageMetadataStore.getInstance().removeMetadata(pluginDescriptor.id()); }
@Autowired public PackageRepositoryService(PluginManager pluginManager, PackageRepositoryExtension packageRepositoryExtension, GoConfigService goConfigService, SecurityService securityService, EntityHashingService entityHashingService) { this.pluginManager = pluginManager; this.packageRepositoryExtension = packageRepositoryExtension; this.goConfigService = goConfigService; this.securityService = securityService; this.entityHashingService = entityHashingService; repositoryMetadataStore = RepositoryMetadataStore.getInstance(); }
public void addConfigurations(List<ConfigurationProperty> configurations) { ConfigurationPropertyBuilder builder = new ConfigurationPropertyBuilder(); for (ConfigurationProperty property : configurations) { RepositoryConfiguration repositoryMetadata = RepositoryMetadataStore.getInstance().getRepositoryMetadata(pluginConfiguration.getId()); if (isValidPluginConfiguration(property.getConfigKeyName(), repositoryMetadata)) { configuration.add(builder.create(property.getConfigKeyName(), property.getConfigValue(), property.getEncryptedValue(), repositoryPropertyFor(property.getConfigKeyName(), repositoryMetadata).getOption(Property.SECURE))); } else { configuration.add(property); } } }
public static void clearSingletons() { AnalyticsMetadataStore.instance().clear(); ArtifactMetadataStore.instance().clear(); AuthorizationMetadataStore.instance().clear(); ConfigRepoMetadataStore.instance().clear(); ElasticAgentMetadataStore.instance().clear(); NewSCMMetadataStore.instance().clear(); NotificationMetadataStore.instance().clear(); PackageMaterialMetadataStore.instance().clear(); PluggableTaskMetadataStore.instance().clear(); new CachingSubjectDnX509PrincipalExtractor().getCache().removeAll(); // SessionUtils.unsetCurrentUser(); // PackageMetadataStore.getInstance().clear(); PluggableTaskConfigStore.store().clear(); PluginSettingsMetadataStore.getInstance().clear(); RepositoryMetadataStore.getInstance().clear(); SCMMetadataStore.getInstance().clear(); } }
void fetchRepositoryAndPackageMetaData(GoPluginDescriptor pluginDescriptor) { try { RepositoryConfiguration repositoryConfiguration = packageRepositoryExtension.getRepositoryConfiguration(pluginDescriptor.id()); com.thoughtworks.go.plugin.api.material.packagerepository.PackageConfiguration packageConfiguration = packageRepositoryExtension.getPackageConfiguration(pluginDescriptor.id()); if (repositoryConfiguration == null) { throw new RuntimeException(format("Plugin[%s] returned null repository configuration", pluginDescriptor.id())); } if (packageConfiguration == null) { throw new RuntimeException(format("Plugin[%s] returned null package configuration", pluginDescriptor.id())); } repositoryMetadataStore.addMetadataFor(pluginDescriptor.id(), new PackageConfigurations(repositoryConfiguration)); packageMetadataStore.addMetadataFor(pluginDescriptor.id(), new PackageConfigurations(packageConfiguration)); } catch (GoPluginFrameworkException e) { LOGGER.error("Failed to fetch package metadata for plugin : {}", pluginDescriptor.id(), e); } }
public RepositoryConfiguration getRepositoryMetadata(String pluginId) { PackageConfigurations metadata = repositoryMetadataStore.getMetadata(pluginId); if (metadata != null) { return metadata.getRepositoryConfiguration(); } return null; } }
@Override public void pluginUnLoaded(GoPluginDescriptor pluginDescriptor) { repositoryMetadataStore.removeMetadata(pluginDescriptor.id()); packageMetadataStore.removeMetadata(pluginDescriptor.id()); } }
public boolean validatePluginId(PackageRepository packageRepository) { String pluginId = packageRepository.getPluginConfiguration().getId(); if (isEmpty(pluginId)) { packageRepository.getPluginConfiguration().errors().add(PluginConfiguration.ID, "Please select package repository plugin"); return false; } for (String currentPluginId : repositoryMetadataStore.getPlugins()) { if (currentPluginId.equals(pluginId)) { GoPluginDescriptor pluginDescriptor = pluginManager.getPluginDescriptorFor(pluginId); packageRepository.getPluginConfiguration().setVersion(pluginDescriptor.version()); return true; } } packageRepository.getPluginConfiguration().errors().add(PluginConfiguration.ID, "Invalid plugin id"); return false; }
void performPluginValidationsFor(final PackageRepository packageRepository) { if (!validatePluginId(packageRepository)) { return; } for (ConfigurationProperty configurationProperty : packageRepository.getConfiguration()) { String key = configurationProperty.getConfigurationKey().getName(); String pluginId = packageRepository.getPluginConfiguration().getId(); if (repositoryMetadataStore.hasOption(pluginId, key, PackageConfiguration.REQUIRED)) { if (configurationProperty.getValue().isEmpty()) { configurationProperty.addErrorAgainstConfigurationValue("This field is required"); } } } ValidationResult validationResult = packageRepositoryExtension.isRepositoryConfigurationValid(packageRepository.getPluginConfiguration().getId(), populateConfiguration(packageRepository.getConfiguration())); for (ValidationError error : validationResult.getErrors()) { packageRepository.addConfigurationErrorFor(error.getKey(), error.getMessage()); } }
@Test public void shouldConvertKeysToLowercaseInGetConfigForDisplay() throws Exception { RepositoryMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations()); PackageMetadataStore.getInstance().addMetadataFor("some-plugin", new PackageConfigurations()); Configuration configuration = new Configuration(create("kEY1", false, "vALue1"), create("KEY_MORE_2", false, "VALUE_2"), create("key_3", false, "value3")); PackageRepository repository = PackageRepositoryMother.create("repo1", "repo1-name", "some-plugin", "1", configuration); assertThat(repository.getConfigForDisplay(), is("Repository: [key1=vALue1, key_more_2=VALUE_2, key_3=value3]")); }
public static void clear() { List<String> plugins = RepositoryMetadataStore.getInstance().getPlugins(); for (String pluginId : plugins) { RepositoryMetadataStore.getInstance().removeMetadata(pluginId); PackageMetadataStore.getInstance().removeMetadata(pluginId); } } }