public void pause(String pipelineName, String pauseCause, Username userName) { pause(pipelineName, pauseCause, userName, new DefaultLocalizedOperationResult()); }
public void unpause(String pipelineName) { unpause(pipelineName, SessionUtils.currentUsername(), new DefaultLocalizedOperationResult()); }
public void check(OperationResult result) { HealthStateType id = HealthStateType.general(HealthStateScope.forPipeline(pipelineName)); if (pipelinePauseService.isPaused(pipelineName)) { String message = String.format("Failed to trigger pipeline [%s]", pipelineName); result.conflict(message, String.format("Pipeline %s is paused", pipelineName), id); } else { result.success(id); } } }
private void unpausePipeline(String pipelineName, Username unpausedBy) { String mutextPipelineName = mutexForPausePipeline(pipelineName); synchronized (mutextPipelineName) { pipelineSqlMapDao.unpause(pipelineName); LOGGER.info("[Pipeline Unpause] Pipeline [{}] is unpaused by [{}]", pipelineName, unpausedBy); notifyListeners(PipelinePauseChangeListener.Event.unPause(pipelineName, unpausedBy)); } }
public void unpause(String pipelineName, Username unpausedBy, LocalizedOperationResult result) { String unpauseByUserName = unpausedBy == null ? "" : unpausedBy.getUsername().toString(); if (pipelineDoesNotExist(pipelineName, result) || notAuthorized(pipelineName, unpauseByUserName, result)) { return; } if (!isPipelinePaused(pipelineName)) { result.conflict("Failed to unpause pipeline '" + pipelineName + "'. Pipeline '" + pipelineName + "' is already unpaused."); return; } try { unpausePipeline(pipelineName, unpausedBy); result.setMessage("Pipeline '" + pipelineName + "' unpaused successfully."); } catch (Exception e) { LOGGER.error("[Pipeline Unpause] Failed to unpause pipeline", e); result.internalServerError("Server error occured. Check log for details."); } }
public void pause(String pipelineName, String pauseCause, Username pausedBy, LocalizedOperationResult result) { String pauseByUserName = pausedBy == null ? "" : pausedBy.getUsername().toString(); if (pipelineDoesNotExist(pipelineName, result) || notAuthorized(pipelineName, pauseByUserName, result)) { return; } if (StringUtils.isBlank(pauseCause)) { pauseCause = ""; } if (isPipelinePaused(pipelineName)) { result.conflict("Failed to pause pipeline '" +pipelineName + "'. Pipeline '" +pipelineName + "' is already paused."); return; } try { pausePipeline(pipelineName, pauseCause, pausedBy); result.setMessage("Pipeline '" + pipelineName + "' paused successfully."); } catch (Exception e) { LOGGER.error("[Pipeline Pause] Failed to pause pipeline", e); result.internalServerError("Server error occured. Check log for details."); } }
public boolean isPaused(String pipelineName) { return pipelinePauseInfo(pipelineName).isPaused(); }
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; }); } }
private void pausePipeline(String pipelineName, String pauseCause, Username pauseBy) { String mutexPipelineName = mutexForPausePipeline(pipelineName); synchronized (mutexPipelineName) { String sanitizedPauseCause = pauseCause.substring(0, Math.min(255, pauseCause.length())); String pauseByDisplayName = pauseBy.getDisplayName(); String sanitizedPauseBy = pauseByDisplayName.substring(0, Math.min(255, pauseByDisplayName.length())); pipelineSqlMapDao.pause(pipelineName, sanitizedPauseCause, sanitizedPauseBy); LOGGER.info("[Pipeline Pause] Pipeline [{}] is paused by [{}] because [{}]", pipelineName, pauseBy, pauseCause); notifyListeners(PipelinePauseChangeListener.Event.pause(pipelineName, pauseBy)); } }
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 String pause(Request req, Response res) throws IOException { HttpLocalizedOperationResult result = new HttpLocalizedOperationResult(); JsonReader requestBody = GsonTransformer.getInstance().jsonReaderFrom(req.body()); String pipelineName = req.params("pipeline_name"); String pauseCause = requestBody.optString("pause_cause").orElse(null); pipelinePauseService.pause(pipelineName, pauseCause, currentUsername(), result); return renderHTTPOperationResult(result, req, res); }
public String unpause(Request req, Response res) throws IOException { HttpLocalizedOperationResult result = new HttpLocalizedOperationResult(); String pipelineName = req.params("pipeline_name"); pipelinePauseService.unpause(pipelineName, currentUsername(), result); return renderHTTPOperationResult(result, req, res); }
@RequestMapping(value = "/**/pipelineHistory.json", method = RequestMethod.GET) public ModelAndView list(@RequestParam("pipelineName") String pipelineName, @RequestParam(value = "perPage", required = false) Integer perPageParam, @RequestParam(value = "start", required = false) Integer startParam, @RequestParam(value = "labelFilter", required = false) String labelFilter, HttpServletResponse response, HttpServletRequest request) { PipelineConfig pipelineConfig = goConfigService.pipelineConfigNamed(new CaseInsensitiveString(pipelineName)); String username = CaseInsensitiveString.str(SessionUtils.currentUsername().getUsername()); Pagination pagination; try { pagination = Pagination.pageStartingAt(startParam, pipelineHistoryService.totalCount(pipelineName), perPageParam); } catch (Exception e) { Map<String, Object> json = new LinkedHashMap<>(); addDeveloperErrorMessage(json, e); return jsonNotAcceptable(json).respond(response); } PipelinePauseInfo pauseInfo = pipelinePauseService.pipelinePauseInfo(pipelineName); boolean hasBuildCauseInBuffer = pipelineScheduleQueue.hasBuildCause(pipelineConfig.name()); PipelineInstanceModels pipelineHistory = StringUtils.isBlank(labelFilter) ? pipelineHistoryService.load(pipelineName, pagination, username, true) : pipelineHistoryService.findMatchingPipelineInstances(pipelineName, labelFilter, perPageParam, SessionUtils.currentUsername(), new HttpLocalizedOperationResult()); boolean hasForcedBuildCause = pipelineScheduleQueue.hasForcedBuildCause(pipelineConfig.name()); PipelineHistoryJsonPresentationModel historyJsonPresenter = new PipelineHistoryJsonPresentationModel( pauseInfo, pipelineHistory, pipelineConfig, pagination, canForce(pipelineConfig, username), hasForcedBuildCause, hasBuildCauseInBuffer, canPause(pipelineConfig, username)); return jsonFound(historyJsonPresenter.toJson()).respond(response); }
public void automaticallyTriggerRelevantStagesFollowingCompletionOf(Stage stage) { if (!stage.isCompleted()) { return; } try { Pipeline pipeline = pipelineDao.loadPipeline(stage.getPipelineId()); unlockIfNecessary(pipeline, stage); if (pipelinePauseService.isPaused(pipeline.getName())) { return; } // if there has been a newer successful run of the previous stage, we should trigger off this stage again // in the same pipeline instance that the newer successful run happened in. //TODO: ChrisS & LYH : This is only accidentally working // if (shouldTriggerThisStageInNewerPipeline(pipeline, stage)) { triggerCurrentStageInNewerPipeline(pipeline.getName(), stage); } // if this stage completed successfully, we should try to trigger the next stage in this pipeline if (stage.isCompletedAndPassed()) { triggerNextStageInPipeline(pipeline, stage.getName(), DEFAULT_APPROVED_BY); } } catch (Exception ex) { String message = String.format("Failed to trigger next stage for %s.", stage.getName()); LOGGER.error(message, ex); throw ex; } }
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); }
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; }
private PipelineGroupModels allPipelineInstances(Username username) { CruiseConfig currentConfig = goConfigService.currentCruiseConfig(); PipelineGroups groups = currentConfig.getGroups(); PipelineInstanceModels activePipelines = filterPermissions(pipelineDao.loadActivePipelines(), username); PipelineGroupModels groupModels = new PipelineGroupModels(); for (PipelineConfig pipelineConfig : currentConfig.getAllPipelineConfigs()) { CaseInsensitiveString pipelineName = pipelineConfig.name(); for (PipelineInstanceModel activePipeline : activePipelines.findAll(CaseInsensitiveString.str(pipelineName))) { activePipeline.setTrackingTool(pipelineConfig.getTrackingTool()); activePipeline.setMingleConfig(pipelineConfig.getMingleConfig()); populatePlaceHolderStages(activePipeline); String groupName = groups.findGroupNameByPipeline(pipelineName); if (groupName == null) { throw new RuntimeException("Unable to find group find pipeline " + pipelineName); } populatePreviousStageState(activePipeline); populateLockStatus(activePipeline.getName(), username, activePipeline); boolean canForce = schedulingCheckerService.canManuallyTrigger(CaseInsensitiveString.str(pipelineName), username); PipelinePauseInfo pauseInfo = pipelinePauseService.pipelinePauseInfo(CaseInsensitiveString.str(pipelineName)); groupModels.addPipelineInstance(groupName, activePipeline, canForce, securityService.hasOperatePermissionForPipeline( username.getUsername(), CaseInsensitiveString.str(pipelineName) ), pauseInfo); } } for (PipelineConfigs group : groups) { populateMissingPipelines(username, groupModels, group); } return groupModels; }