Map<String, String> loadWorkItemDefinitionElements() { final Map<String, String> workItemDefinitionElements = new HashMap<String, String>(); final List<ConfigGroup> editorConfigGroups = configurationService.getConfiguration(ConfigType.EDITOR); for (ConfigGroup editorConfigGroup : editorConfigGroups) { if (WORK_ITEMS_EDITOR_SETTINGS.equals(editorConfigGroup.getName())) { for (ConfigItem item : editorConfigGroup.getItems()) { final String itemName = item.getName(); final String itemValue = editorConfigGroup.getConfigItemValue(itemName); workItemDefinitionElements.put(itemName, itemValue); } } } return workItemDefinitionElements; }
private ConfigGroup createSpaceConfigGroup(final Space space, final List<Contributor> contributors) { final ConfigGroup configGroup = spy(new ConfigGroup()); configGroup.setName(space.getName()); configGroup.addConfigItem(configurationFactory.newConfigItem("space-contributors", contributors)); return configGroup; }
private void checkIfRepositoryContributorsIsNotSet(final ConfigGroup repoConfig, final Repository repository, final Space space) { if (repoConfig.getConfigItem("contributors") == null) { final Optional<ConfigGroup> spaceConfig = configurationService.getConfiguration(SPACE).stream().filter(s -> s.getName().equals(space.getName())).findFirst(); ConfigItem<List<Contributor>> spaceContributors = spaceConfig.get().getConfigItem("space-contributors"); if (spaceContributors != null) { spaceContributors.getValue().forEach(c -> repository.getContributors().add(c)); repoConfig.addConfigItem(configurationFactory.newConfigItem("contributors", repository.getContributors())); configurationService.updateConfiguration(repoConfig); } } }
@Override public ConfigGroup newConfigGroup(final ConfigType type, final String name, final String description) { final ConfigGroup configGroup = new ConfigGroup(); configGroup.setDescription(description); configGroup.setName(name); configGroup.setType(type); configGroup.setEnabled(true); return configGroup; }
private void invalidateCacheAfterUpdatingConfigGroup(final ConfigGroup configGroup) { final ConfigType type = configGroup.getType(); if (!type.hasNamespace()) { configGroupsByTypeWithoutNamespace.remove(type); } else { if (configGroupsByTypeWithNamespace.containsKey(type)) { configGroupsByTypeWithNamespace.get(type).remove(configGroup.getNamespace()); } } }
static Map<String, String> getOrgUnitsByRepo(List<ConfigGroup> orgUnitConfigs) { Map<String, String> orgUnitByRepo = new LinkedHashMap<>(); orgUnitConfigs .stream() .forEach(group -> { @SuppressWarnings("unchecked") ConfigItem<List<String>> repos = group.getConfigItem("repositories"); Optional.ofNullable(repos) .map(r -> r.getValue()) .ifPresent(r -> r.forEach(repo -> orgUnitByRepo.put(repo, group.getName()))); }); return orgUnitByRepo; }
@Test public void newConfigGroupWithoutNamespaceTest() { final ConfigGroup configGroup = configurationFactory.newConfigGroup(ConfigType.GLOBAL, "my-config", "my-description"); assertEquals(ConfigType.GLOBAL, configGroup.getType()); assertEquals("my-config", configGroup.getName()); assertEquals("my-description", configGroup.getDescription()); assertTrue(configGroup.isEnabled()); }
@Test public void testWorkitemDefinitions() throws Exception { ConfigGroup group = workbenchConfigurationHelper.getWorkItemElementDefinitions(); assertEquals(ConfigType.EDITOR, group.getType()); assertEquals(WorkItemsEditorService.WORK_ITEMS_EDITOR_SETTINGS, group.getName()); assertEquals("", group.getDescription()); assertEquals(6, group.getItems().size()); assertEquals("\"customEditor\" : \"true\"", group.getConfigItemValue(WorkItemsEditorService.WORK_ITEMS_EDITOR_SETTINGS_CUSTOM_EDITOR)); assertEquals("\"parameterValues\" : [\n" + " \"MyFirstParam\" : \"A,B,C\", \n" + " \"MySecondParam\" : \"X,Y,Z\"\n" + "]", group.getConfigItemValue(WorkItemsEditorService.WORK_ITEMS_EDITOR_SETTINGS_PARAMETER_VALUES)); }
@Override public OrganizationalUnit newOrganizationalUnit(ConfigGroup groupConfig) { OrganizationalUnitImpl organizationalUnit = new OrganizationalUnitImpl(groupConfig.getName(), groupConfig.getConfigItemValue("owner"), groupConfig.getConfigItemValue("defaultGroupId")); ConfigItem<List<String>> repositories = groupConfig.getConfigItem("repositories"); if (repositories != null) { for (String alias : repositories.getValue()) { final Repository repo = repositoryService.getRepository(alias); if (repo != null) { organizationalUnit.getRepositories().add(repo); } } } //Copy in Security Roles required to access this resource ConfigItem<List<String>> groups = backward.compat(groupConfig).getConfigItem("security:groups"); if (groups != null) { for (String group : groups.getValue()) { organizationalUnit.getGroups().add(group); } } return organizationalUnit; } }
public void bootstrapConfig() { ConfigGroup deploymentServiceTypeConfig = null; List<ConfigGroup> configGroups = configurationService.getConfiguration( ConfigType.GLOBAL ); if ( configGroups != null ) { for ( ConfigGroup configGroup : configGroups ) { if ( DEPLOYMENT_SERVICE_TYPE_CONFIG.equals( configGroup.getName() ) ) { deploymentServiceTypeConfig = configGroup; break; } } } if ( deploymentServiceTypeConfig == null ) { deploymentServiceTypeConfig = configurationFactory.newConfigGroup( ConfigType.GLOBAL, DEPLOYMENT_SERVICE_TYPE_CONFIG, "" ); deploymentServiceTypeConfig.addConfigItem( configurationFactory.newConfigItem( "type", "kjar" ) ); configurationService.addConfiguration( deploymentServiceTypeConfig ); } deploymentServiceType = deploymentServiceTypeConfig.getConfigItemValue( "type" ); }
private int getMaxRuleFirings() { for (ConfigGroup editorConfigGroup : configurationService.getConfiguration(ConfigType.EDITOR)) { if (ScenarioTestEditorService.TEST_SCENARIO_EDITOR_SETTINGS.equals(editorConfigGroup.getName())) { for (ConfigItem item : editorConfigGroup.getItems()) { String itemName = item.getName(); if (itemName.equals(ScenarioTestEditorService.TEST_SCENARIO_EDITOR_MAX_RULE_FIRINGS)) { return (Integer) item.getValue(); } } } } return 0; }
@PostConstruct public void loadOrganizationalUnits() { Collection<ConfigGroup> groups = configurationService.getConfiguration(ConfigType.ORGANIZATIONAL_UNIT); if (groups != null) { for (ConfigGroup groupConfig : groups) { // Make sure existing Organizational Units are correctly initialized with a default group id. String ouName = groupConfig.getName(); String defaultGroupId = groupConfig.getConfigItemValue("defaultGroupId"); if (defaultGroupId == null || defaultGroupId.trim().isEmpty()) { groupConfig.setConfigItem(configurationFactory.newConfigItem("defaultGroupId", getSanitizedDefaultGroupId(ouName))); configurationService.updateConfiguration(groupConfig); } OrganizationalUnit ou = organizationalUnitFactory.newOrganizationalUnit(groupConfig); registeredOrganizationalUnits.put(ou.getName(), ou); } } }
public Repository build(final ConfigGroup repoConfig) { ConfigItem space = repoConfig.getConfigItem(EnvironmentParameters.SPACE); if (space == null) { throw new IllegalStateException("Repository " + repoConfig.getName() + " space is not valid"); } repo = new GitRepository(repoConfig.getName(), spacesAPI.getSpace(space.getValue().toString())); if (!repo.isValid()) { throw new IllegalStateException("Repository " + repoConfig.getName() + " not valid"); } else { addEnvironmentParameters(repoConfig.getItems()); FileSystem fileSystem = createFileSystem(repo); setBranches(fileSystem); setPublicURIs(fileSystem); return repo; } }
@Override public boolean updateConfiguration(final ConfigGroup configGroup) { if (ConfigType.SPACE.equals(configGroup.getType())) { configGroup.setType(ConfigType.ORGANIZATIONAL_UNIT); } String filename = configGroup.getName().replaceAll(INVALID_FILENAME_CHARS, "_"); final Path filePath = ioService.get(systemRepository.getUri()).resolve(filename + configGroup.getType().getExt()); final CommentedOption commentedOption = new CommentedOption(getIdentityName(), "Updated config " + filePath.getFileName()); saveConfiguration(configGroup, filePath, commentedOption); configGroupsByTypeWithoutNamespace.remove(configGroup.getType()); return true; }
@Test public void updateConfigurationWithNamespaceTest() { final ConfigGroup config = configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "namespace", "config", "description"); config.addConfigItem(configurationFactory.newConfigItem("space", "namespace")); configurationService.addConfiguration(config); config.setDescription("new-description"); configurationService.updateConfiguration(config); final List<ConfigGroup> configGroups = configurationService.getConfiguration(ConfigType.REPOSITORY, "namespace"); assertEquals(1, configGroups.size()); assertEquals("config", configGroups.get(0).getName()); assertEquals("new-description", configGroups.get(0).getDescription()); }
@Test public void updateConfigurationWithoutNamespaceTest() { final ConfigGroup config = configurationFactory.newConfigGroup(ConfigType.GLOBAL, "config", "description"); configurationService.addConfiguration(config); config.setDescription("new-description"); configurationService.updateConfiguration(config); final List<ConfigGroup> configGroups = configurationService.getConfiguration(ConfigType.GLOBAL); assertEquals(1, configGroups.size()); assertEquals("config", configGroups.get(0).getName()); assertEquals("new-description", configGroups.get(0).getDescription()); }
private ConfigGroup generateOUConfigGroup(final String name, final String defaultGroupId, final List<String> repositories, final List<String> groups) { final ConfigGroup configGroup = configurationFactory.newConfigGroup(ConfigType.SPACE, name, ""); configGroup.addConfigItem(configurationFactory.newConfigItem("defaultGroupId", defaultGroupId)); configGroup.addConfigItem(configurationFactory.newConfigItem("repositories", repositories)); configGroup.addConfigItem(configurationFactory.newConfigItem("security:groups", groups)); return configGroup; } }
@Test public void testNewRepositoryReplaceIfExists() throws Exception { rootDirectories.add(createPath("default://master@uf-playground")); ConfigGroup configGroup = getConfigGroup(); configGroup.setName("test"); ConfigItem configItem = new ConfigItem(); configItem.setName("replaceIfExists"); configItem.setValue(true); configGroup.setConfigItem(configItem); when(ioService.newFileSystem(any(URI.class), anyMap())) .thenThrow(FileSystemAlreadyExistsException.class) .thenReturn(fileSystem); when(ioService.getFileSystem(any(URI.class))).thenReturn(fileSystem); helper.newRepository(configGroup); verify(ioService, times(1)).delete(any(Path.class)); verify(ioService, times(2)).newFileSystem(any(URI.class), anyMap()); }
@Override public boolean removeConfiguration(final ConfigGroup configGroup) { //Invalidate cache if an item has been removed; otherwise cached value is stale configuration.remove(configGroup.getType()); String filename = configGroup.getName().replaceAll(INVALID_FILENAME_CHARS, "_"); final Path filePath = ioService.get(systemRepository.getUri()).resolve(filename + configGroup.getType().getExt()); // avoid duplicated writes to not cause cyclic cluster sync if (!ioService.exists(filePath)) { return true; } boolean result; try { ioService.startBatch(filePath.getFileSystem()); result = ioService.deleteIfExists(filePath); if (result) { updateLastModified(); } } catch (Exception ex) { throw new RuntimeException(ex); } finally { ioService.endBatch(); } return result; }
@Test public void updateConfigurationWithNamespaceTest() { final ConfigGroup config = configurationFactory.newConfigGroup(ConfigType.REPOSITORY, "namespace", "config", "description"); configurationService.addConfiguration(config); config.setDescription("new-description"); configurationService.updateConfiguration(config); final List<ConfigGroup> configGroups = configurationService.getConfiguration(ConfigType.REPOSITORY, "namespace"); assertEquals(1, configGroups.size()); assertEquals("config", configGroups.get(0).getName()); assertEquals("namespace", configGroups.get(0).getNamespace()); assertEquals("new-description", configGroups.get(0).getDescription()); }