private String calcPipelinesDataEtag(Username username, List<PipelineConfigs> pipelineConfigs) { final HashMap<String, List<CaseInsensitiveString>> pipelinesDataSegment = new HashMap<>(); for (PipelineConfigs group : pipelineConfigs) { final List<PipelineConfig> pipelines = group.getPipelines(); if (!pipelines.isEmpty()) { List<CaseInsensitiveString> pipelineNames = pipelines.stream().map(PipelineConfig::name).collect(Collectors.toList()); pipelinesDataSegment.put(group.getGroup(), pipelineNames); } } return DigestUtils.md5Hex(StringUtils.joinWith("/", username.getUsername(), pipelinesDataSegment)); } }
public List<PipelineConfigs> getGroupsForUser(String userName) { List<PipelineConfigs> pipelineGroups = new ArrayList<>(); for (PipelineConfigs pipelineGroup : goConfigService.groups()) { if (securityService.hasViewPermissionForGroup(userName, pipelineGroup.getGroup())) { pipelineGroups.add(pipelineGroup); } } return pipelineGroups; }
public List<PipelineConfigs> viewableOrOperatableGroupsFor(Username username) { ArrayList<PipelineConfigs> list = new ArrayList<>(); for (PipelineConfigs pipelineConfigs : goConfigService.cruiseConfig().getGroups()) { if (hasViewOrOperatePermissionForGroup(username, pipelineConfigs.getGroup())) { list.add(pipelineConfigs); } } return list; }
@Override public List<String> getGroupsForUser(CaseInsensitiveString username, List<Role> roles) { ArrayList<String> groups = new ArrayList<>(); for (PipelineConfigs group : this.groups) { if (isAdministrator(username.toString()) || group.isUserAnAdmin(username, roles)) { groups.add(group.getGroup()); } } return groups; }
public List<PipelineConfigs> viewableGroupsFor(Username username) { ArrayList<PipelineConfigs> list = new ArrayList<>(); for (PipelineConfigs pipelineConfigs : goConfigService.cruiseConfig().getGroups()) { if (securityService.hasViewPermissionForGroup(CaseInsensitiveString.str(username.getUsername()), pipelineConfigs.getGroup())) { list.add(pipelineConfigs); } } return list; }
private GoDashboardPipeline createGoDashboardPipeline(PipelineConfig pipelineConfig, Permissions permissions, PipelineInstanceModels historyForDashboard, PipelineConfigs group) { PipelineModel pipelineModel = pipelineModelFor(pipelineConfig, historyForDashboard); Optional<TrackingTool> trackingTool = pipelineConfig.getIntegratedTrackingTool(); return new GoDashboardPipeline(pipelineModel, permissions, group.getGroup(), trackingTool.orElse(null), timeStampBasedCounter, pipelineConfig.getOrigin()); }
public void visit(PipelineConfigs group) { if (hasViewPermission(group.getGroup()) || isUserAGroupAdmin(group)) { visitor.visit(group); } }
@Override public void update(CruiseConfig preprocessedConfig) throws Exception { preprocessedPipelineConfigs = group; try { preprocessedConfig.deletePipelineGroup(group.getGroup()); } catch (PipelineGroupNotEmptyException e) { result.unprocessableEntity(e.getMessage()); } }
public PipelineConfigs updateGroupAuthorization(Username currentUser, PipelineConfigs newPipelineConfigs, String existingMd5, EntityHashingService entityHashingService, SecurityService securityService, LocalizedOperationResult result) { UpdatePipelineConfigsAuthCommand updatePipelineConfigsCommand = new UpdatePipelineConfigsAuthCommand(newPipelineConfigs.getGroup(), newPipelineConfigs.getAuthorization(), result, currentUser, existingMd5, entityHashingService, securityService); update(currentUser, newPipelineConfigs, result, updatePipelineConfigsCommand); return updatePipelineConfigsCommand.getPreprocessedEntityConfig(); }
public void deleteGroup(Username currentUser, PipelineConfigs pipelineConfigs, HttpLocalizedOperationResult result) { DeletePipelineConfigsCommand deletePipelineConfigsCommand = new DeletePipelineConfigsCommand(pipelineConfigs, result, currentUser, securityService); update(currentUser, pipelineConfigs, result, deletePipelineConfigsCommand); if (result.isSuccessful()) { result.setMessage(LocalizedMessage.resourceDeleteSuccessful("Pipeline group", pipelineConfigs.getGroup())); } }
@Test public void shouldUpdateName() { PipelineConfigs group = createWithPipeline(PipelineConfigMother.pipelineConfig("pipeline1")); group.setConfigAttributes(m(BasicPipelineConfigs.GROUP, "my-new-group")); assertThat(group.getGroup(), is("my-new-group")); group.setConfigAttributes(m()); assertThat(group.getGroup(), is("my-new-group")); group.setConfigAttributes(null); assertThat(group.getGroup(), is("my-new-group")); group.setConfigAttributes(m(BasicPipelineConfigs.GROUP, null)); assertThat(group.getGroup(), is(nullValue())); }
public String create(Request req, Response res) { PipelineConfigs pipelineConfigsFromReq = buildEntityFromRequestBody(req); String groupName = pipelineConfigsFromReq.getGroup(); Optional<PipelineConfigs> pipelineConfigsFromServer = findPipelineGroup(groupName); if (pipelineConfigsFromServer.isPresent()) { pipelineConfigsFromReq.addError("name", LocalizedMessage.resourceAlreadyExists("pipeline group", groupName)); throw haltBecauseEntityAlreadyExists(jsonWriter(pipelineConfigsFromReq), "pipeline group", groupName); } HttpLocalizedOperationResult result = new HttpLocalizedOperationResult(); pipelineConfigsService.createGroup(SessionUtils.currentUsername(), pipelineConfigsFromReq, result); return handleCreateOrUpdateResponse(req, res, pipelineConfigsFromReq, result); }
@Test public void shouldSetToDefaultGroupWithGroupNameIsEmptyString() { PipelineConfigs pipelineConfigs = createEmpty(); pipelineConfigs.setGroup(""); assertThat(pipelineConfigs.getGroup(), is(BasicPipelineConfigs.DEFAULT_GROUP)); }
private void validateDependencies(CruiseConfig preprocessedConfig) { List<CaseInsensitiveString> pipelineNames = preprocessedConfig.pipelinesAssociatedWithTemplate(this.name()); ParamsConfig paramsConfig = this.referredParams(); for (CaseInsensitiveString pipelineName : pipelineNames) { PipelineConfig pipelineConfig = preprocessedConfig.getPipelineConfigByName(pipelineName); PipelineConfigs pipelineGroup = preprocessedConfig.findGroupOfPipeline(pipelineConfig); PipelineConfigSaveValidationContext contextForStages = PipelineConfigSaveValidationContext.forChain(false, pipelineGroup.getGroup(), preprocessedConfig, pipelineConfig); validateParams(pipelineConfig, paramsConfig); validatePartsOfPipelineConfig(pipelineConfig, contextForStages); validateDependenciesOfDownstreams(pipelineConfig, contextForStages); } }
@Test(expected = RuntimeException.class) public void shouldSetToDefaultGroupWithGroupNameIsEmptyString() { PipelineConfigs pipelineConfigs = new MergePipelineConfigs(new BasicPipelineConfigs()); pipelineConfigs.setGroup(""); assertThat(pipelineConfigs.getGroup(), is(BasicPipelineConfigs.DEFAULT_GROUP)); }
private void populateMissingPipelines(Username username, PipelineGroupModels groupModels, PipelineConfigs group) { String groupName = group.getGroup(); for (PipelineConfig pipelineConfig : group) { if (!groupModels.containsPipeline(groupName, CaseInsensitiveString.str(pipelineConfig.name()))) { PipelineModel latestPipeline = latestPipelineModel(username, CaseInsensitiveString.str(pipelineConfig.name())); if (latestPipeline != null) { groupModels.addPipelineInstance(groupName, latestPipeline.getLatestPipelineInstance(), latestPipeline.canForce(), latestPipeline.canOperate(), latestPipeline.getPausedInfo()); } } } }
@Test(expected = RuntimeException.class) public void shouldFailToUpdateName() { PipelineConfigs group = new MergePipelineConfigs( new BasicPipelineConfigs(PipelineConfigMother.pipelineConfig("pipeline1")), new BasicPipelineConfigs(PipelineConfigMother.pipelineConfig("pipeline2"))); group.setConfigAttributes(m(BasicPipelineConfigs.GROUP, "my-new-group")); assertThat(group.getGroup(), is("my-new-group")); }
@Test public void shouldApplyChangesToPipelineWhenPartEditable() { BasicPipelineConfigs filePart = new BasicPipelineConfigs(PipelineConfigMother.pipelineConfig("pipeline1")); filePart.setOrigin(new FileConfigOrigin()); PipelineConfigs group = new MergePipelineConfigs(filePart); PipelineConfig pipelineConfig = (PipelineConfig) group.get(0).clone(); pipelineConfig.setLabelTemplate("blah"); group.update(group.getGroup(), pipelineConfig, "pipeline1"); assertThat(group.get(0).getLabelTemplate(), is("blah")); }
@Test public void shouldFailValidateWhenUpstreamPipelineForDependencyMaterialDoesNotExist() { String upstreamPipeline = "non-existant"; PipelineConfig pipelineConfig = GoConfigMother.createPipelineConfigWithMaterialConfig( new DependencyMaterialConfig(new CaseInsensitiveString(upstreamPipeline), new CaseInsensitiveString("non-existant"))); BasicCruiseConfig cruiseConfig = new BasicCruiseConfig(new BasicPipelineConfigs(pipelineConfig)); boolean isValid = pipelineConfig.validateTree(PipelineConfigSaveValidationContext.forChain(true, cruiseConfig.getGroups().first().getGroup(), cruiseConfig, pipelineConfig)); assertThat(isValid, is(false)); ConfigErrors materialErrors = pipelineConfig.materialConfigs().first().errors(); assertThat(materialErrors.isEmpty(), is(false)); assertThat(materialErrors.firstError(), is("Pipeline with name 'non-existant' does not exist, it is defined as a dependency for pipeline 'pipeline' (cruise-config.xml)")); }