private StageNotificationDTO.StageDTO createStageDTO() { ArrayList<StageNotificationDTO.JobDTO> jobs = new ArrayList<>(); for (JobInstance job : stage.getJobInstances()) { StageNotificationDTO.JobDTO jobDTO = new StageNotificationDTO.JobDTO(job.getName(), job.getScheduledDate(), job.getAssignedDate(), job.getCompletedDate(), job.getState(), job.getResult(), job.getAgentUuid()); jobs.add(jobDTO); } return new StageNotificationDTO.StageDTO(stage.getName(), stage.getCounter(), stage.getApprovalType(), stage.getApprovedBy(), stage.getState(), stage.getResult(), stage.getCreatedTime(), stage.getLastTransitionedTime(), jobs); }
private JobInstance passJob(Date date, int id, int transitionIdStart, JobInstance jobInstance) { jobInstance.setId(id); jobInstance.changeState(JobState.Completed, date); for (JobStateTransition jobStateTransition : jobInstance.getTransitions()) { jobStateTransition.setId(++transitionIdStart); } jobInstance.setResult(JobResult.Passed); return jobInstance; }
private JobInstance createJobInstance(JobHistoryItem job, JobIdentifier jobIdentifier, String agentUUID) { JobInstance jobInstance = new JobInstance(job.getName()); jobInstance.setIdentifier(jobIdentifier); jobInstance.setState(job.getState()); jobInstance.setScheduledDate(job.getScheduledDate()); jobInstance.setAgentUuid(agentUUID); return jobInstance; } }
public void completing(JobResult result, Date completionDate) { if (isPreparing()) { this.changeState(JobState.Building, completionDate); } this.result = result; this.changeState(JobState.Completing, completionDate); }
public String getBuildDurationKey(String pipelineName, String stageName) { return String.format("BUILD_DURATION: %s_%s_%s_%s", pipelineName, stageName, getName(), getAgentUuid()); }
void resetForCopy() { if (!isCopy()) { setOriginalJobId(getId()); } setId(-1); rerun = false; stateTransitions.resetTransitionIds(); }
public static void toJSON(OutputWriter jsonWriter, JobInstance jobInstance) { jsonWriter.add("id", jobInstance.getId()); jsonWriter.add("name", jobInstance.getName()); if (jobInstance.getState() != null) { jsonWriter.add("state", jobInstance.getState().toString()); } if (jobInstance.getResult() != null) { jsonWriter.add("result", jobInstance.getResult().toString()); } if (jobInstance.getScheduledDate() != null) { jsonWriter.add("scheduled_date", jobInstance.getScheduledDate().getTime()); } jsonWriter.add("rerun", jobInstance.isRerun()); if (jobInstance.getOriginalJobId() == null) { jsonWriter.add("original_job_id", (String) null); } else { jsonWriter.add("original_job_id", jobInstance.getOriginalJobId()); } jsonWriter.addWithDefaultIfBlank("agent_uuid", jobInstance.getAgentUuid(), (String) null); jsonWriter.add("pipeline_name", (String) null); jsonWriter.add("pipeline_counter", (String) null); jsonWriter.add("stage_name", (String) null); jsonWriter.add("stage_counter", (String) null); jsonWriter.addChildList("job_state_transitions", jobStateTransitionsWriter -> jobInstance.getTransitions().forEach( jobStateTransition -> jobStateTransitionsWriter.addChild( jobStateTransitionWriter -> JobStateTransitionRepresenter.toJSON(jobStateTransitionWriter, jobStateTransition)))); } }
private static Consumer<OutputListWriter> runningJobsToJSON(List<JobInstance> runningJobs) { return listWriter -> { runningJobs.stream().forEach(job -> { listWriter.addChild(childItemWriter -> { childItemWriter.add("pipeline_name", job.getPipelineName()); childItemWriter.add("pipeline_counter", job.getPipelineCounter()); childItemWriter.add("stage_name", job.getStageName()); childItemWriter.add("stage_counter", job.getStageCounter()); childItemWriter.add("name", job.getName()); childItemWriter.add("state", job.getState().toString()); childItemWriter.add("scheduled_date", new Timestamp(job.getScheduledDate().getTime())); childItemWriter.add("agent_uuid", job.getAgentUuid()); }); }); }; } }
private void assertCopiedJob(JobInstance newJava, final long originalId) { assertThat(newJava.getId(), is(-1l)); assertThat(newJava.getTransitions().isEmpty(), is(false)); assertThat(newJava.getResult(), is(Passed)); assertThat(newJava.getState(), is(Completed)); assertThat(newJava.getTransitions().byState(Scheduled).getId(), is(-1l)); assertThat(newJava.getTransitions().byState(Completed).getId(), is(-1l)); assertThat(newJava.getOriginalJobId(), is(originalId)); assertThat(newJava.isRerun(), is(false)); assertThat(newJava.isCopy(), is(true)); }
public void doInTransactionWithoutResult(TransactionStatus status) { if (job.isNull() || job.getState() == JobState.Rescheduled || job.getResult() == JobResult.Cancelled) { return; } job.changeState(jobState); //TODO: #2318 JobInstance should contain identifier after it's loaded from database job.setIdentifier(jobIdentifier); jobInstanceService.updateStateAndResult(job); synchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() { @Override public void afterCommit() { stageDao.clearCachedAllStages(jobIdentifier.getPipelineName(), jobIdentifier.getPipelineCounter(), jobIdentifier.getStageName()); } }); if (job.isCompleted()) { Stage stage = stageService.stageById(job.getStageId()); stageService.updateResult(stage); } } });
private void assertRunOnAllAgentsJobInstance(JobInstance jobInstance, String jobName) { assertThat(jobInstance.getName(), is(jobName)); assertThat(jobInstance.isRunOnAllAgents(), is(true)); assertThat(jobInstance.isRunMultipleInstance(), is(false)); assertThat(jobInstance.isRerun(), is(false)); }
private JobStateTransition assertNewJob(JobInstance newRails) { assertThat(newRails.getId(), is(-1l)); assertThat(newRails.getTransitions().size(), is(1)); JobStateTransition newSchedulingTransition = newRails.getTransitions().byState(JobState.Scheduled); assertThat(newSchedulingTransition.getId(), is(-1l)); assertThat(newRails.getResult(), is(Unknown)); assertThat(newRails.getState(), is(Scheduled)); assertThat(newRails.isRerun(), is(true)); return newSchedulingTransition; }
private void logIfJobIsCompleted(JobInstance jobInstance) { JobState currentState = getCurrentState(jobInstance.getId()); if (currentState.isCompleted() && !jobInstance.isCopy()) { String message = String.format( "State change for a completed Job is not allowed. Job %s is currently State=%s, Result=%s", jobInstance.getIdentifier(), jobInstance.getState(), jobInstance.getResult()); LOG.warn(message, new Exception().fillInStackTrace()); } }
@Test public void shouldCleanAgentIdAndResultAfterRescheduled() throws Exception { JobInstance instance = JobInstanceMother.assignedWithAgentId("testBuild", "uuid"); instance.completing(JobResult.Failed); instance.reschedule(); assertThat(instance.getState(), is(JobState.Scheduled)); assertThat(instance.getAgentUuid(), is(nullValue())); assertThat(instance.getResult(), is(JobResult.Unknown)); }
public static StageInstanceModel toStageInstanceModel(Stage stage) { StageInstanceModel stageInstanceModel = new StageInstanceModel(stage.getName(), String.valueOf(stage.getCounter()), stage.getResult(), stage.getIdentifier()); stageInstanceModel.setApprovalType(stage.getApprovalType()); stageInstanceModel.setApprovedBy(stage.getApprovedBy()); stageInstanceModel.setRerunOfCounter(stage.getRerunOfCounter()); JobHistory jobHistory = new JobHistory(); for (JobInstance jobInstance : stage.getJobInstances()) { jobHistory.addJob(jobInstance.getName(), jobInstance.getState(), jobInstance.getResult(), jobInstance.getScheduledDate()); } stageInstanceModel.setBuildHistory(jobHistory); return stageInstanceModel; }
@Test public void shouldSetCompletedTimeOnComplete() throws Exception { JobInstance instance = JobInstanceMother.scheduled("jobConfig1"); final Date completionDate = new Date(); instance.completing(JobResult.Passed, completionDate); instance.completed(completionDate); assertThat(instance.getResult(), is(JobResult.Passed)); assertThat(instance.getStartedDateFor(JobState.Completed), is(completionDate)); assertThat(instance.getState(), is(JobState.Completed)); }
private JobDetailPresentationModel presenter(JobInstance current) { String pipelineName = current.getIdentifier().getPipelineName(); String stageName = current.getIdentifier().getStageName(); JobInstances recent25 = jobInstanceService.latestCompletedJobs(pipelineName, stageName, current.getName()); AgentConfig agentConfig = goConfigService.agentByUuid(current.getAgentUuid()); Pipeline pipelineWithOneBuild = pipelineService.wrapBuildDetails(current); Tabs customizedTabs = goConfigService.getCustomizedTabs(pipelineWithOneBuild.getName(), pipelineWithOneBuild.getFirstStage().getName(), current.getName()); TrackingTool trackingTool = goConfigService.pipelineConfigNamed( new CaseInsensitiveString(pipelineWithOneBuild.getName())).trackingTool(); Properties properties = propertiesService.getPropertiesForJob(current.getId()); Stage stage = stageService.getStageByBuild(current); return new JobDetailPresentationModel(current, recent25, agentConfig, pipelineWithOneBuild, customizedTabs, trackingTool, artifactService, properties, stage); }
@Test public void shouldReturnBuildInstance() { ArtifactConfigs artifactConfigs = new ArtifactConfigs(); JobConfig jobConfig = new JobConfig(new CaseInsensitiveString("test"), null, artifactConfigs); RunOnAllAgents.CounterBasedJobNameGenerator jobNameGenerator = new RunOnAllAgents.CounterBasedJobNameGenerator(CaseInsensitiveString.str(jobConfig.name())); JobInstances jobs = instanceFactory.createJobInstance(new CaseInsensitiveString("stage_foo"), jobConfig, new DefaultSchedulingContext(), new TimeProvider(), jobNameGenerator); JobInstance jobInstance = jobs.first(); assertThat(jobConfig.name(), is(new CaseInsensitiveString(jobInstance.getName()))); assertThat(jobInstance.getState(), is(JobState.Scheduled)); assertThat(jobInstance.getScheduledDate(), is(notNullValue())); }
@Override protected void doInTransactionWithoutResult(TransactionStatus status) { LOGGER.warn("[Job Reschedule] Rescheduling and marking old job as ignored: {}", toBeRescheduled); //Reloading it because we want to see the latest committed state after acquiring the mutex. JobInstance oldJob = jobInstanceService.buildById(toBeRescheduled.getId()); if (oldJob.isCompleted() || oldJob.isRescheduled()) { return; } JobInstance newJob = oldJob.clone(); oldJob.changeState(JobState.Rescheduled); jobInstanceService.updateStateAndResult(oldJob); //Make a new Job newJob.reschedule(); jobInstanceService.save(oldJob.getIdentifier().getStageIdentifier(), oldJob.getStageId(), newJob); //Copy the plan for the old job since we don't load job plan with jobInstance by default JobPlan plan = jobInstanceDao.loadPlan(oldJob.getId()); jobInstanceDao.ignore(oldJob); jobInstanceDao.save(newJob.getId(), plan); LOGGER.info("[Job Reschedule] Scheduled new job: {}. Replacing old job: {}", newJob.getIdentifier(), oldJob.getIdentifier()); } });
public boolean isCancelledOrRescheduled(Long buildInstanceId) { JobInstance instance = jobInstanceService.buildByIdWithTransitions(buildInstanceId); if (instance.isNull()) { return false; } boolean cancelled = instance.getResult() == JobResult.Cancelled; boolean rescheduled = instance.getState() == JobState.Rescheduled; return cancelled || rescheduled; } }