public List<CaseInsensitiveString> names() { List<CaseInsensitiveString> names = new ArrayList<>(); for (JobConfig jobConfig : this) { names.add(jobConfig.name()); } return names; } }
public JobConfig jobConfigByConfigName(final CaseInsensitiveString jobName) { for (JobConfig jobConfig : jobConfigs) { if (jobConfig.name().equals(jobName)) { return jobConfig; } } return null; }
public JobConfig getJob(final CaseInsensitiveString job) { for (JobConfig jobConfig : this) { if (jobConfig.name().equals(job)) return jobConfig; } return null; }
public boolean containsName(final CaseInsensitiveString jobName) { for (JobConfig jobConfig : this) { if (jobName.equals(jobConfig.name())) { return true; } } return false; }
public void validateNameUniqueness(Map<String, JobConfig> visitedConfigs) { if (isBlank(CaseInsensitiveString.str(name()))) return; String currentJob = name().toLower(); if (visitedConfigs.containsKey(CaseInsensitiveString.str(name())) || visitedConfigs.containsKey(currentJob)) { JobConfig conflictingConfig = visitedConfigs.get(currentJob); conflictingConfig.addUniquenessViolationMessage(); this.addUniquenessViolationMessage(); } else { visitedConfigs.put(currentJob, this); } }
private void populateReferences(List<Map<JobConfigIdentifier, List<PluggableArtifactConfig>>> usedByPipelines, PipelineConfig pipelineConfig) { for (StageConfig stage : pipelineConfig) { JobConfigs jobs = stage.getJobs(); for (JobConfig job : jobs) { final List<PluggableArtifactConfig> artifactConfigs = job.artifactConfigs().findByStoreId(profile.getId()); if (!artifactConfigs.isEmpty()) { usedByPipelines.add(Collections.singletonMap(new JobConfigIdentifier(pipelineConfig.name(), stage.name(), job.name()), artifactConfigs)); } } } } }
private void populateDups(List<JobConfigIdentifier> usedByPipelines, PipelineConfig pipelineConfig) { for (StageConfig stage : pipelineConfig) { JobConfigs jobs = stage.getJobs(); for (JobConfig job : jobs) { String id = profile.getId(); if (id.equals(job.getElasticProfileId())) { usedByPipelines.add(new JobConfigIdentifier(pipelineConfig.name(), stage.name(), job.name())); } } } }
private void validateWorkingDirectory(ValidationContext validationContext, String stageParentType, Object stageParentName) { if (workingDirectory != null && !FilenameUtil.isNormalizedPathOutsideWorkingDir(workingDirectory)) { errors.add(WORKING_DIRECTORY, String.format("Task of job '%s' in stage '%s' of %s '%s' has path '%s' which is outside the working directory.", validationContext.getJob().name(), validationContext.getStage().name(), stageParentType, stageParentName, workingDirectory)); } }
private void validateStagesOfSamePipeline(ValidationContext validationContext, PipelineConfig currentPipeline) { List<StageConfig> validStages = currentPipeline.validStagesForFetchArtifact(currentPipeline, validationContext.getStage().name()); StageConfig matchingStage = validStages.stream().filter(stageConfig -> stageConfig.name().equals(stage)).findFirst().orElse(null); if (matchingStage == null) { addError(STAGE, String.format("\"%s :: %s :: %s\" tries to fetch artifact from its stage \"%s\" which does not complete before the current stage \"%s\"." , currentPipeline.name(), validationContext.getStage().name(), validationContext.getJob().name(), stage, validationContext.getStage().name())); } }
public void createJobInstances(JobInstances jobs, SchedulingContext context, JobConfig config, String stageName, final JobNameGenerator nameGenerator, final Clock clock, InstanceFactory instanceFactory) { Collection<AgentConfig> agents = context.findAgentsMatching(config.resourceConfigs()); int counter = 0; for (AgentConfig agent : agents) { instanceFactory.reallyCreateJobInstance(config, jobs, agent.getUuid(), nameGenerator.generateName(++counter), true, false, context, clock); } if (counter == 0) { throw new CannotScheduleException(String.format("Could not find matching agents to run job [%s] of stage [%s].", config.name(), stageName), stageName); } }
@Test public void shouldNotSetJobNameIfNotGiven() throws Exception { JobConfig config = new JobConfig("some-job-name"); config.setConfigAttributes(m()); assertThat(config.name(), is(new CaseInsensitiveString("some-job-name"))); config.setConfigAttributes(m(JobConfig.NAME, null)); assertThat(config.name(), is(nullValue())); }
private void validateFilePath(ValidationContext validationContext, String path, String propertyName) { if (path == null) { return; } if (!FilenameUtil.isNormalizedPathOutsideWorkingDir(path)) { String parentType = validationContext.isWithinPipelines() ? "pipeline" : "template"; CaseInsensitiveString parentName = validationContext.isWithinPipelines() ? validationContext.getPipeline().name() : validationContext.getTemplate().name(); String message = String.format("Task of job '%s' in stage '%s' of %s '%s' has %s path '%s' which is outside the working directory.", validationContext.getJob().name(), validationContext.getStage().name(), parentType, parentName, propertyName, path); addError(propertyName, message); } }
public static JobHistory buildHistory(StageConfig stageConfig, Date modificationDate) { JobHistory history = new JobHistory(); for (JobConfig jobConfig : stageConfig.allBuildPlans()) { history.addJob(CaseInsensitiveString.str(jobConfig.name()), JobState.Completed, JobResult.Passed, modificationDate); } return history; }
public static NullStage createNullStage(StageConfig stageConfig) { JobInstances nullBuilds = new JobInstances(); for (JobConfig plan : stageConfig.allBuildPlans()) { nullBuilds.add(new NullJobInstance(CaseInsensitiveString.str(plan.name()))); } NullStage nullStage = new NullStage(CaseInsensitiveString.str(stageConfig.name()), nullBuilds); nullStage.setPipelineId(10l); return nullStage; }
@Test public void shouldAddJobsGivenInTheAttributesMapAfterClearingExistingJobs() throws Exception{ JobConfigs jobs = new JobConfigs(); jobs.add(new JobConfig("quux")); jobs.setConfigAttributes(a(m(JobConfig.NAME, "foo"), m(JobConfig.NAME, "bar"))); assertThat(jobs.get(0).name(), is(new CaseInsensitiveString("foo"))); assertThat(jobs.get(1).name(), is(new CaseInsensitiveString("bar"))); assertThat(jobs.size(), is(2)); }
@Test public void shouldCopyAttributeValuesFromAttributeMap() throws Exception { config = new JobConfig();//override the setup mock TaskFactory taskFactory = mock(TaskFactory.class); ExecTask emptyExecTask = new ExecTask(); when(taskFactory.taskInstanceFor(emptyExecTask.getTaskType())).thenReturn(emptyExecTask); config.setConfigAttributes(DataStructureUtils.m(JobConfig.NAME, "foo-job", JobConfig.TASKS, DataStructureUtils.m(Tasks.TASK_OPTIONS, "exec", "exec", DataStructureUtils.m(Task.TASK_TYPE, "exec", ExecTask.COMMAND, "ls", ExecTask.ARGS, "-la", ExecTask.WORKING_DIR, "/tmp"))), taskFactory); assertThat(config.name(), is(new CaseInsensitiveString("foo-job"))); assertThat(config.getTasks().get(0), is(new ExecTask("ls", "-la", "/tmp"))); assertThat(config.getTasks().size(), is(1)); }
@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())); }
@Test public void shouldPickupJobConfigDetailsFromAttributeMap() throws Exception{ StageConfig config = new StageConfig(); Map stageAttrs = m(StageConfig.JOBS, a(m(JobConfig.NAME, "con-job"), m(JobConfig.NAME, "boring-job"))); config.setConfigAttributes(stageAttrs); assertThat(config.getJobs().get(0).name(), is(new CaseInsensitiveString("con-job"))); assertThat(config.getJobs().get(1).name(), is(new CaseInsensitiveString("boring-job"))); }
private FetchTask fetchTaskFromSamePipeline(PipelineConfig pipelineConfig) { FetchTask fetchTask = new FetchTask(); fetchTask.setStage(pipelineConfig.first().name()); fetchTask.setJob(pipelineConfig.first().getJobs().first().name()); return fetchTask; }
@Test public void shouldPassValidationWhenSrcAndDestDirectoryAreInsideAgentSandbox() { StageConfig stage = upstream.getFirstStageConfig(); JobConfig job = stage.getJobs().get(0); FetchTask task = new FetchTask(upstream.name(), stage.name(), job.name(), "src", "dest"); task.validate(ConfigSaveValidationContext.forChain(upstream, stage, job)); assertThat(task.errors().isEmpty(), is(true)); }