public void add(PipelineModel pipelineModel) { PipelineModel model = getExistingPipelineModelOrCacheThisOneAndGetItBack(new PipelineModel(pipelineModel, false)); for (PipelineInstanceModel pipelineInstanceModel : pipelineModel.getActivePipelineInstances()) { model.addPipelineInstance(pipelineInstanceModel); } }
/** * Note: this check should be part of the scheduling checker. * We will refactor it down to that point. */ public boolean canForce() { return canForce && !getLatestPipelineInstance().isPreparingToSchedule(); }
private String keyForPipelineModelFragment(PipelineModel model, String name) { PipelinePauseInfo pauseInfo = model.getPausedInfo(); return cacheKeyGenerator.generate("view", name, model.getName(), appendLockStatus(model), getPipelineInstanceModelAsKey(model), model.canOperate(), model.canForce(), pauseInfo.isPaused(), pauseInfo.getPauseCause().replaceAll("\\W", ""), pauseInfo.getPauseBy(), model.canAdminister() ); }
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 public void shouldUnderstandCanOperateAndCanForce() { PipelineModel foo = new PipelineModel("foo", true, true, PipelinePauseInfo.notPaused()); foo.addPipelineInstance(pipelineNamed("foo")); PipelineModel bar = new PipelineModel("bar", false, false, PipelinePauseInfo.notPaused()); bar.addPipelineInstance(pipelineNamed("bar")); PipelineModel baz = new PipelineModel("baz", false, true, PipelinePauseInfo.notPaused()); baz.addPipelineInstance(pipelineNamed("baz")); assertThat(foo.canOperate(), is(true)); assertThat(foo.canForce(), is(true)); assertThat(bar.canOperate(), is(false)); assertThat(bar.canForce(), is(false)); assertThat(baz.canOperate(), is(true)); assertThat(baz.canForce(), is(false)); }
private String getPipelineInstanceModelAsKey(PipelineModel model) { final StringBuilder builder = new StringBuilder(); for (PipelineInstanceModel pim : model.getActivePipelineInstances()) { builder.append("["); builder.append(pim.getId()).append(DELIMITER); for (StageInstanceModel stageInstanceModel : pim.getStageHistory()) { builder.append(stageInstanceModel.getName()).append(DELIMITER); builder.append(stageInstanceModel.getId()).append(DELIMITER); builder.append(stageInstanceModel.getState()).append(DELIMITER); } builder.append("]"); } return builder.toString(); }
@Test public void shouldUnderstandIfHasNewRevisions() throws Exception { PipelineInstanceModel instanceModel = PipelineInstanceModel.createPipeline("pipelineName", -1, "1", BuildCause.createManualForced(), new StageInstanceModels()); MaterialRevisions latest = ModificationsMother.createHgMaterialRevisions(); instanceModel.setMaterialConfigs(new MaterialConfigs(latest.getMaterialRevision(0).getMaterial().config())); instanceModel.setLatestRevisions(latest); PipelineModel pipelineModel = new PipelineModel(instanceModel.getName(), true, true, PipelinePauseInfo.notPaused()); pipelineModel.addPipelineInstance(instanceModel); instanceModel.setMaterialRevisionsOnBuildCause(MaterialRevisions.EMPTY); assertThat(pipelineModel.hasNewRevisions(), is(true)); instanceModel.setMaterialRevisionsOnBuildCause(latest); assertThat(pipelineModel.hasNewRevisions(), is(false)); }
public PipelineModel latestPipelineModel(Username username, String pipelineName) { PipelineInstanceModel instanceModel = latest(pipelineName, username); if (instanceModel != null) { boolean canForce = schedulingCheckerService.canManuallyTrigger(pipelineName, username); PipelinePauseInfo pauseInfo = pipelinePauseService.pipelinePauseInfo(pipelineName); PipelineModel pipelineModel = new PipelineModel(pipelineName, canForce, securityService.hasOperatePermissionForPipeline( username.getUsername(), pipelineName ), pauseInfo); populateLockStatus(instanceModel.getName(), username, instanceModel); pipelineModel.addPipelineInstance(instanceModel); String groupName = goConfigService.findGroupNameByPipeline(new CaseInsensitiveString(pipelineName)); if (goConfigService.isPipelineEditable(pipelineName)) pipelineModel.updateAdministrability(goConfigService.isUserAdminOfGroup(username.getUsername(), groupName)); else pipelineModel.updateAdministrability(false); return pipelineModel; } return null; }
@Test public void shouldNotBeAbleToscheduleIfTheLatestPipelineIsPreparingToSchedule() throws Exception { PipelineInstanceModel instanceModel = PipelineInstanceModel.createPreparingToSchedule("pipelineName", new StageInstanceModels()); PipelineModel pipelineModel = new PipelineModel(instanceModel.getName(), true, true, PipelinePauseInfo.notPaused()); pipelineModel.addPipelineInstance(instanceModel); assertThat(pipelineModel.canForce(), is(false)); }
private PipelineModel pipelineModelFor(PipelineConfig pipelineConfig, PipelineInstanceModels historyForDashboard) { String pipelineName = str(pipelineConfig.name()); PipelinePauseInfo pauseInfo = pipelinePauseService.pipelinePauseInfo(pipelineName); boolean canBeForced = schedulingCheckerService.pipelineCanBeTriggeredManually(pipelineConfig); PipelineModel pipelineModel = new PipelineModel(pipelineName, canBeForced, true, pauseInfo); pipelineModel.updateAdministrability(pipelineConfig.isLocal()); pipelineModel.addPipelineInstances(instancesFor(pipelineConfig, historyForDashboard)); return pipelineModel; }
public PipelineModel getPipelineModel(String pipelineName) { for (PipelineModel pipelineModel : pipelineModels) { if (pipelineModel.getName().equalsIgnoreCase(pipelineName)) { return pipelineModel; } } return null; }
private PipelineModel addInstanceTo(PipelineModel pipelineModel) { pipelineModel.addPipelineInstance(new PipelineInstanceModel(pipelineModel.getName(), 1, "label", BuildCause.createManualForced(), new StageInstanceModels())); return pipelineModel; } }
public static PipelineModel pipeline() { PipelineModel pipelineModel = new PipelineModel("pipe1", true, true, PipelinePauseInfo.notPaused()); MaterialRevisions materialRevisions = ModificationsMother.createHgMaterialRevisions(); PipelineInstanceModel instanceModel = PipelineInstanceModel.createPipeline("pipe1", -1, "label1", BuildCause.createWithModifications(materialRevisions, "foo-bar"), new StageInstanceModels()); instanceModel.setMaterialConfigs(new MaterialConfigs(materialRevisions.getMaterialRevision(0).getMaterial().config())); instanceModel.setLatestRevisions(materialRevisions); pipelineModel.addPipelineInstance(instanceModel); return pipelineModel; } }
private void updateGroupAdministrability(Username username, PipelineGroupModels groupModels) { for (PipelineGroupModel groupModel : groupModels.asList()) { if (!goConfigService.isUserAdminOfGroup(username.getUsername(), groupModel.getName())) { continue; } for (PipelineModel pipelineModel : groupModel.getPipelineModels()) { if (goConfigService.isPipelineEditable(pipelineModel.getName())) pipelineModel.updateAdministrability(true); } } }
@Test public void shouldCopyAllInternalsOfPipelineModelWhenCreatingANewOneIfNeeded() throws Exception { PipelineGroupModel groupModel = new PipelineGroupModel("group"); PipelineModel expectedModel = addInstanceTo(new PipelineModel("p1", true, true, PipelinePauseInfo.notPaused())); expectedModel.updateAdministrability(true); groupModel.add(expectedModel); PipelineModel actualModel = groupModel.getPipelineModel("p1"); String message = String.format("\nExpected: %s\nActual: %s", reflectionToString(expectedModel), reflectionToString(actualModel)); assertThat(message, EqualsBuilder.reflectionEquals(actualModel, expectedModel), is(true)); }
private static Consumer<OutputWriter> getPauseInfoNEW(GoDashboardPipeline model) { return writer -> { PipelinePauseInfo pausedInfo = model.model().getPausedInfo(); writer.add("paused", pausedInfo.isPaused()); writer.add("paused_by", StringUtils.isBlank(pausedInfo.getPauseBy()) ? null : pausedInfo.getPauseBy()); writer.add("pause_reason", StringUtils.isBlank(pausedInfo.getPauseCause()) ? null : pausedInfo.getPauseCause()); }; }
public boolean hasNewRevisions() { for (PipelineModel pipelinesModel : pipelinesModels) { if (pipelinesModel.hasNewRevisions()) { return true; } } return false; } }
public PipelineModel addPipelineInstances(PipelineInstanceModels instanceModels) { for (PipelineInstanceModel instanceModel : instanceModels) { addPipelineInstance(instanceModel); } return this; }
public PipelineModel pipelineModelForPipelineName(String pipelineName, boolean canForce, boolean canOperate, PipelinePauseInfo pipelinePauseInfo) { return getExistingPipelineModelOrCacheThisOneAndGetItBack(new PipelineModel(pipelineName, canForce, canOperate, pipelinePauseInfo)); }
private String appendActivePipelineInstanceModels(PipelineModel model, StringBuilder s) { for (PipelineInstanceModel pim : model.getActivePipelineInstances()) { TrackingTool trackingTool = pim.getTrackingTool(); MingleConfig mingleConfig = pim.getMingleConfig(); int trackingToolHash = trackingTool == null ? -1 : trackingTool.hashCode(); int mingleToolHash = mingleConfig == null ? -1 : mingleConfig.hashCode(); s.append("[").append(pim.getId()).append("|").append(trackingToolHash).append("|").append(mingleToolHash).append("]"); } return s.toString(); } }