public void check(OperationResult result) { if (!lockService.canScheduleStageInPipeline(pipeline)) { result.notAcceptable(String.format("Pipeline %s is locked.", pipeline.getName()), HealthStateType.general(HealthStateScope.GLOBAL)); } } }
public void check(OperationResult result) { HealthStateType healthStateType = HealthStateType.general(HealthStateScope.forPipeline(pipelineName)); if (pipelineLockService.isLocked(pipelineName)) { String message = format("Pipeline %s cannot be scheduled", pipelineName); String description = format("Pipeline %s is locked as another instance of this pipeline is running.", pipelineName); result.conflict(message, description, healthStateType); } else{ result.success(healthStateType); } } }
public boolean isLocked(String pipelineName) { return lockedPipeline(pipelineName) != null; }
public void unlock(String pipelineName, Username username, OperationResult result) { if (canUnlock(pipelineName, username, result)) { pipelineLockService.unlock(pipelineName); result.ok("Pipeline lock released for " + pipelineName); } }
public void unlock(String pipelineName) { pipelineStateDao.unlockPipeline(pipelineName, (AfterCompletionCallback) status -> { if (status != TransactionSynchronization.STATUS_COMMITTED) { return; } notifyListeners(PipelineLockStatusChangeListener.Event.unLock(pipelineName)); }); }
public Pipeline save(final Pipeline pipeline) { String mutexPipelineName = PipelinePauseService.mutexForPausePipeline(pipeline.getName()); synchronized (mutexPipelineName) { return (Pipeline) transactionTemplate.execute((TransactionCallback) status -> { if (pipeline instanceof NullPipeline) { return pipeline; } updateCounter(pipeline); Pipeline pipelineWithId = pipelineDao.save(pipeline); pipelineLockService.lockIfNeeded(pipelineWithId); for (Stage stage : pipeline.getStages()) { stageService.save(pipelineWithId, stage); } pipelineTimeline.update(); return pipelineWithId; }); } }
public void initialize() { goConfigService.register(this); goConfigService.register(pipelineConfigChangedListener()); }
@Override public void initialize() { goConfigService.register(this); goConfigService.register(pipelineConfigChangedListener()); goConfigService.register(securityConfigChangeListener()); goConfigService.register(templateConfigChangedListener()); stageService.addStageStatusListener(stageStatusChangedListener()); pipelinePauseService.registerListener(this); pipelineLockService.registerListener(this); }
invalidConfigMessageRemover.initialize(); agentService.initialize(); pipelineLockService.initialize(); buildAssignmentService.initialize(); materialUpdateService.initialize();
public void onConfigChange(CruiseConfig newCruiseConfig) { for (String lockedPipeline : pipelineStateDao.lockedPipelines()) { if (!newCruiseConfig.hasPipelineNamed(new CaseInsensitiveString(lockedPipeline)) || !newCruiseConfig.isPipelineLockable(lockedPipeline)) { unlock(lockedPipeline); } } }
public void lockIfNeeded(Pipeline pipeline) { if (goConfigService.isLockable(pipeline.getName())) { pipelineStateDao.lockPipeline(pipeline, (AfterCompletionCallback) status -> { if(status == TransactionSynchronization.STATUS_COMMITTED) { notifyListeners(PipelineLockStatusChangeListener.Event.lock(pipeline.getName())); } }); } }
public Stage scheduleStage(final Pipeline pipeline, final String stageName, final String username, final StageInstanceCreator creator, final ErrorConditionHandler errorHandler) { return (Stage) transactionTemplate.execute((TransactionCallback) status -> { String pipelineName = pipeline.getName(); PipelineConfig pipelineConfig = goConfigService.pipelineConfigNamed(new CaseInsensitiveString(pipelineName)); StageConfig stageConfig = pipelineConfig.findBy(new CaseInsensitiveString(stageName)); if (stageConfig == null) { throw new StageNotFoundException(pipelineName, stageName); } SchedulingContext context = schedulingContext(username, pipelineConfig, stageConfig); pipelineLockService.lockIfNeeded(pipeline); Stage instance = null; try { instance = creator.create(pipelineName, stageName, context); LOGGER.info("[Stage Schedule] Scheduling stage {} for pipeline {}", stageName, pipeline.getName()); } catch (CannotScheduleException e) { serverHealthService.update(stageSchedulingFailedState(pipelineName, e)); errorHandler.cantSchedule(e, pipelineName); } serverHealthService.update(stageSchedulingSuccessfulState(pipelineName, stageName)); stageService.save(pipeline, instance); return instance; }); }
private void populateLockStatus(String pipelineName, Username username, PipelineInstanceModel pipelineInstanceModel) { pipelineInstanceModel.setCanUnlock(pipelineUnlockService.canUnlock(pipelineName, username, new HttpOperationResult())); pipelineInstanceModel.setIsLockable(goConfigService.isLockable(pipelineName)); pipelineInstanceModel.setCurrentlyLocked(pipelineLockService.isLocked(pipelineName)); }
@Override public void onEntityConfigChange(PipelineConfig pipelineConfig) { for (String lockedPipeline : pipelineStateDao.lockedPipelines()) { if (pipelineConfig.name().equals(new CaseInsensitiveString(lockedPipeline)) && !pipelineConfig.isLockable()) { unlock(lockedPipeline); break; } } } };
public boolean canScheduleStageInPipeline(PipelineIdentifier pipeline) { if (!goConfigService.isLockable(pipeline.getName())) { return true; } StageIdentifier locked = lockedPipeline(pipeline.getName()); return locked == null || locked.pipelineIdentifier().equals(pipeline); }
private PipelineInstanceModels instancesFor(PipelineConfig pipelineConfig, PipelineInstanceModels historyForDashboard) { PipelineInstanceModels pims = findPIMsWithFallbacks(pipelineConfig, historyForDashboard); boolean isCurrentlyLocked = pipelineLockService.isLocked(str(pipelineConfig.name())); boolean isUnlockable = pipelineUnlockApiService.isUnlockable(str(pipelineConfig.name())); for (PipelineInstanceModel instanceModel : pims) { populateStagesWhichHaventRunFromConfig(instanceModel, pipelineConfig); populateLockStatus(instanceModel, pipelineConfig.isLockable(), isCurrentlyLocked, isUnlockable); } return pims; }
public void unlockIfNecessary(Pipeline pipeline, Stage stage) { StageConfig nextStage = stageOrderService.getNextStage(pipeline, stage.getName()); boolean isLastStage = nextStage == null; boolean isUnlockable = goConfigService.isUnlockableWhenFinished(pipeline.getName()); boolean nextStageIsManual = nextStage != null && nextStage.requiresApproval(); boolean pipelineIsConsideredToBeComplete = stage.isCompleted() && (!stage.passed() || nextStageIsManual); if (isLastStage || (isUnlockable && pipelineIsConsideredToBeComplete)) { pipelineLockService.unlock(pipeline.getName()); } }
private boolean isUnlockable(String pipelineName, OperationResult result) { if (!goConfigService.isLockable(pipelineName)) { String msg = format("No lock exists within the pipeline configuration for %s", pipelineName); result.conflict(msg, msg, HealthStateType.general(HealthStateScope.GLOBAL)); return false; } StageIdentifier stageIdentifier = pipelineLockService.lockedPipeline(pipelineName); if (stageIdentifier == null) { String msg = "Lock exists within the pipeline configuration but no pipeline instance is currently in progress"; result.conflict(msg, msg, HealthStateType.general(HealthStateScope.GLOBAL)); return false; } if (stageService.isAnyStageActiveForPipeline(stageIdentifier.pipelineIdentifier())) { String message = "Locked pipeline instance is currently running (one of the stages is in progress)"; result.conflict(message, message, HealthStateType.general(HealthStateScope.GLOBAL)); return false; } return true; }
public PipelineStatusModel getPipelineStatus(String pipelineName, String username, OperationResult result) { PipelineConfig pipelineConfig = goConfigService.currentCruiseConfig().getPipelineConfigByName(new CaseInsensitiveString(pipelineName)); if (pipelineConfig == null) { result.notFound("Not Found", "Pipeline not found", HealthStateType.general(HealthStateScope.GLOBAL)); return null; } if (!securityService.hasViewPermissionForPipeline(Username.valueOf(username), pipelineName)) { result.forbidden("Forbidden", NOT_AUTHORIZED_TO_VIEW_PIPELINE, HealthStateType.general(HealthStateScope.forPipeline(pipelineName))); return null; } PipelinePauseInfo pipelinePauseInfo = pipelinePauseService.pipelinePauseInfo(pipelineName); boolean isCurrentlyLocked = pipelineLockService.isLocked(pipelineName); boolean isSchedulable = schedulingCheckerService.canManuallyTrigger(pipelineConfig, username, new ServerHealthStateOperationResult()); return new PipelineStatusModel(isCurrentlyLocked, isSchedulable, pipelinePauseInfo); }