CRJob jobToCRJob(JobConfig jobConfig) { CRJob job = new CRJob(); job.setName(jobConfig.name().toString()); job.setResources(jobConfig.resourceConfigs().resourceNames()); job.setElasticProfileId(jobConfig.getElasticProfileId()); for (EnvironmentVariableConfig var: jobConfig.getVariables()) { job.addEnvironmentVariable(environmentVariableConfigToCREnvironmentVariable(var)); } for (ArtifactPropertyConfig prop: jobConfig.getProperties()) { job.addProperty(new CRPropertyGenerator(prop.getName(), prop.getSrc(), prop.getXpath())); } for(Tab tab: jobConfig.getTabs()) { job.addTab(new CRTab(tab.getName(), tab.getPath())); } for (ArtifactConfig artifactConfig: jobConfig.artifactConfigs()) { job.addArtifact(artifactConfigToCRArtifact(artifactConfig)); } if (jobConfig.isRunOnAllAgents()) { job.setRunOnAllAgents(jobConfig.isRunOnAllAgents()); } else { job.setRunInstanceCount(jobConfig.getRunInstanceCountValue()); } for (Task task: jobConfig.tasks()) { job.addTask(taskToCRTask(task)); } if (jobConfig.getTimeout() != null) { job.setTimeout(Integer.valueOf(jobConfig.getTimeout())); } return job; }
@Test public void shouldValidateThatTheTimeoutIsAValidNumber() { JobConfig job = new JobConfig("job"); job.setTimeout("5.5"); job.validate(ConfigSaveValidationContext.forChain(new BasicCruiseConfig())); assertThat(job.errors().isEmpty(), is(true)); }
public static void toJSON(OutputWriter jsonWriter, JobConfig jobConfig) { if (!jobConfig.errors().isEmpty()) { jsonWriter.addChild("errors", errorWriter -> { HashMap<String, String> errorMapping = new HashMap<>(); errorMapping.put("runType", "run_instance_count"); new ErrorGetter(errorMapping).toJSON(errorWriter, jobConfig); }); } jsonWriter.addIfNotNull("name", jobConfig.name()); addRunInstanceCount(jsonWriter, jobConfig); addTimeout(jsonWriter, jobConfig); jsonWriter.addIfNotNull("elastic_profile_id", jobConfig.getElasticProfileId()); jsonWriter.addChildList("environment_variables", envVarsWriter -> EnvironmentVariableRepresenter.toJSON(envVarsWriter, jobConfig.getVariables())); jsonWriter.addChildList("resources", getResourceNames(jobConfig)); jsonWriter.addChildList("tasks", tasksWriter -> TaskRepresenter.toJSONArray(tasksWriter, jobConfig.getTasks())); jsonWriter.addChildList("tabs", tabsWriter -> TabConfigRepresenter.toJSONArray(tabsWriter, jobConfig.getTabs())); jsonWriter.addChildList("artifacts", getArtifacts(jobConfig)); if (jobConfig.getProperties().isEmpty()) { jsonWriter.renderNull("properties"); } else { jsonWriter.addChildList("properties", propertiesWriter -> PropertyConfigRepresenter.toJSONArray(propertiesWriter, jobConfig.getProperties())); } }
private static void addRunInstanceCount(OutputWriter outputWriter, JobConfig jobConfig) { if (jobConfig.isRunOnAllAgents()) { outputWriter.add("run_instance_count", "all"); } else if (jobConfig.getRunInstanceCount() != null && !jobConfig.getRunInstanceCount().isEmpty()) { outputWriter.add("run_instance_count", jobConfig.getRunInstanceCountValue()); } else { outputWriter.add("run_instance_count", (String) null); } }
private void validateElasticProfileId(JobConfig jobConfig, PipelineConfigSaveValidationContext preprocessedConfig) { String elasticProfileId = jobConfig.getElasticProfileId(); if (elasticProfileId != null && !preprocessedConfig.isValidProfileId(elasticProfileId)) { String message = String.format("No profile defined corresponding to profile_id '%s'", elasticProfileId); jobConfig.addError("elasticProfileId", message); this.errors().addAll(jobConfig.errors()); } }
private static void setRunInstanceCount(JobConfig jobConfig) { String runInstanceCount = null; if (jsonReader.hasJsonObject("run_instance_count")) { runInstanceCount = jsonReader.getString("run_instance_count"); } if ("all".equalsIgnoreCase(runInstanceCount)) { jobConfig.setRunOnAllAgents(true); } else if (!"null".equalsIgnoreCase(runInstanceCount)) { jobConfig.setRunInstanceCount(runInstanceCount); } } }
public JobConfig toJobConfig(CRJob crJob) { JobConfig jobConfig = new JobConfig(crJob.getName()); if (crJob.getEnvironmentVariables() != null) for (CREnvironmentVariable crEnvironmentVariable : crJob.getEnvironmentVariables()) { jobConfig.getVariables().add(toEnvironmentVariableConfig(crEnvironmentVariable)); Tasks tasks = jobConfig.getTasks(); if (crTasks != null) for (CRTask crTask : crTasks) { Tabs tabs = jobConfig.getTabs(); if (crJob.getTabs() != null) for (CRTab crTab : crJob.getTabs()) { ResourceConfigs resourceConfigs = jobConfig.resourceConfigs(); if (crJob.getResources() != null) for (String crResource : crJob.getResources()) { jobConfig.setElasticProfileId(crJob.getElasticProfileId()); ArtifactConfigs artifactConfigs = jobConfig.artifactConfigs(); if (crJob.getArtifacts() != null) { for (CRArtifact crArtifact : crJob.getArtifacts()) { ArtifactPropertiesConfig artifactPropertiesConfig = jobConfig.getProperties(); if (crJob.getArtifactPropertiesGenerators() != null) for (CRPropertyGenerator crPropertyGenerator : crJob.getArtifactPropertiesGenerators()) { jobConfig.setRunOnAllAgents(true); else {
public JobPlan createJobPlan(JobConfig config, SchedulingContext context) { JobIdentifier identifier = new JobIdentifier(); String elasticProfileId = config.getElasticProfileId(); ElasticProfile elasticProfile = null; if (elasticProfileId != null) { elasticProfile = context.getElasticProfile(elasticProfileId); } final EnvironmentVariables variables = EnvironmentVariables.toEnvironmentVariables(context.overrideEnvironmentVariables(config.getVariables()).getEnvironmentVariablesConfig()); return new DefaultJobPlan(new Resources(config.resourceConfigs()), ArtifactPlan.toArtifactPlans(config.artifactConfigs()), ArtifactPropertiesGenerator.toArtifactProperties(config.getProperties()), -1, identifier, null, variables, new EnvironmentVariables(), elasticProfile); } }
JobConfig fromJob = fromStage.jobConfigByConfigName(toJob.name()); copy(fromJob, toJob); copyCollectionErrors(fromJob.getTasks(), toJob.getTasks()); copyCollectionErrors(fromJob.artifactConfigs(), toJob.artifactConfigs()); copyCollectionErrors(fromJob.getTabs(), toJob.getTabs()); copyCollectionErrors(fromJob.getProperties(), toJob.getProperties()); copyCollectionErrors(fromJob.getVariables(), toJob.getVariables()); Tasks toTasks = toJob.getTasks(); Tasks fromTasks = fromJob.getTasks(); copyCollectionErrors(fromTasks, toTasks); for (int i = 0; i < toTasks.size(); i++) { List<PluggableArtifactConfig> toPluggableArtifactConfigs = toJob.artifactConfigs().getPluggableArtifactConfigs(); List<PluggableArtifactConfig> fromPluggableArtifactConfigs = fromJob.artifactConfigs().getPluggableArtifactConfigs(); for(int i = 0; i< toPluggableArtifactConfigs.size(); i++) { PluggableArtifactConfig fromPluggableArtifactConfig = fromPluggableArtifactConfigs.get(i);
@Test public void shouldValidateAgainstSettingRunOnAllAgentsAndRunInstanceCountSetTogether() { JobConfig jobConfig = new JobConfig(new CaseInsensitiveString("test")); jobConfig.setRunOnAllAgents(true); jobConfig.setRunInstanceCount(10); jobConfig.validate(ConfigSaveValidationContext.forChain(new BasicCruiseConfig())); ConfigErrors configErrors = jobConfig.errors(); assertThat(configErrors.isEmpty(), is(false)); assertThat(configErrors.on(JobConfig.RUN_TYPE), is("Job cannot be 'run on all agents' type and 'run multiple instance' type together.")); }
@Test public void shouldResetJobRunTypeCorrectly() { HashMap map1 = new HashMap(); map1.put(JobConfig.RUN_TYPE, JobConfig.RUN_MULTIPLE_INSTANCE); map1.put(JobConfig.RUN_INSTANCE_COUNT, "10"); JobConfig jobConfig = new JobConfig(); jobConfig.setConfigAttributes(map1); assertThat(jobConfig.getRunInstanceCountValue(), is(10)); assertThat(jobConfig.isRunMultipleInstanceType(), is(true)); assertThat(jobConfig.isRunOnAllAgents(), is(false)); // should not reset value when correct key not present HashMap map2 = new HashMap(); jobConfig.setConfigAttributes(map2); assertThat(jobConfig.getRunInstanceCountValue(), is(10)); assertThat(jobConfig.isRunMultipleInstanceType(), is(true)); assertThat(jobConfig.isRunOnAllAgents(), is(false)); // reset value for same job config HashMap map3 = new HashMap(); map3.put(JobConfig.RUN_TYPE, JobConfig.RUN_SINGLE_INSTANCE); jobConfig.setConfigAttributes(map3); assertThat(jobConfig.isRunMultipleInstanceType(), is(false)); assertThat(jobConfig.getRunInstanceCount(), is(nullValue())); assertThat(jobConfig.isRunOnAllAgents(), is(false)); }
public static JobConfig jobConfig() { JobConfig job = createJobConfigWithResourceAndArtifactPlans(); addTask(job); job.setTimeout("100"); job.setRunInstanceCount(3); job.artifactConfigs().clear(); job.artifactConfigs().add(new BuildArtifactConfig("target/dist.jar", "pkg")); job.artifactConfigs().add(new TestArtifactConfig("target/reports/**/*Test.xml", "reports")); job.addTab("coverage", "Jcoverage/index.html"); job.addTab("something", "something/path.html"); job.getProperties().add(new ArtifactPropertyConfig("coverage.class", "target/emma/coverage.xml", "substring-before(//report/data/all/coverage[starts-with(@type,'class')]/@value, '%')")); return job; }
@Test public void shouldValidateAgainstSettingRunOnAllAgentsForAJobAssignedToElasticAgent() { JobConfig jobConfig = new JobConfig(new CaseInsensitiveString("test")); jobConfig.setRunOnAllAgents(true); jobConfig.setElasticProfileId("ubuntu-dev"); jobConfig.validate(ConfigSaveValidationContext.forChain(new BasicCruiseConfig())); ConfigErrors configErrors = jobConfig.errors(); assertThat(configErrors.isEmpty(), is(false)); assertThat(configErrors.on(JobConfig.RUN_TYPE), is("Job cannot be set to 'run on all agents' when assigned to an elastic agent")); }
@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)); }
private StageConfig getStageConfig(String stageName, String jobName) { JobConfig jobConfig = new JobConfig(new CaseInsensitiveString(jobName)); jobConfig.addTask(new AntTask()); jobConfig.addTask(new ExecTask("command", "", "workingDir")); jobConfig.artifactConfigs().add(new BuildArtifactConfig("src", "dest")); jobConfig.addVariable("env1", "val1"); jobConfig.addResourceConfig("powerful"); JobConfigs jobConfigs = new JobConfigs(jobConfig); return new StageConfig(new CaseInsensitiveString(stageName), jobConfigs); }
@Test public void shouldReturnRunTypeCorrectly() { JobConfig job = new JobConfig("job"); assertThat(job.getRunType(), is(JobConfig.RUN_SINGLE_INSTANCE)); job.setRunOnAllAgents(true); assertThat(job.getRunType(), is(JobConfig.RUN_ON_ALL_AGENTS)); job.setRunOnAllAgents(false); job.setRunInstanceCount(10); assertThat(job.getRunType(), is(JobConfig.RUN_MULTIPLE_INSTANCE)); }
public void encryptSecureProperties(CruiseConfig preprocessedConfig, PipelineTemplateConfig pipelineTemplateConfig) { List<PluggableArtifactConfig> artifactConfigs = artifactConfigs().getPluggableArtifactConfigs(); artifactConfigs.forEach(artifactConfig -> { artifactConfig.encryptSecureProperties(preprocessedConfig, artifactConfig); }); tasks.forEach(task -> { if (task instanceof FetchPluggableArtifactTask) { FetchPluggableArtifactTask fetchPluggableArtifactTask = (FetchPluggableArtifactTask) task; fetchPluggableArtifactTask.encryptSecureProperties(preprocessedConfig, pipelineTemplateConfig); } }); }
private void cachePublishAndFetchExternalConfig() { externalArtifactConfigs = new ArrayList<>(); fetchExternalArtifactTasks = new ArrayList<>(); for (StageConfig stageConfig : getStages()) { for (JobConfig jobConfig : stageConfig.getJobs()) { externalArtifactConfigs.addAll(jobConfig.artifactConfigs().getPluggableArtifactConfigs()); for (Task task : jobConfig.getTasks()) { if (task instanceof FetchPluggableArtifactTask) { fetchExternalArtifactTasks.add((FetchPluggableArtifactTask) task); } } } } }
@Test public void shouldNotValidateJobNameUniquenessInAbsenceOfName(){ JobConfig job = new JobConfig(); job.validateNameUniqueness(new HashMap<>()); assertTrue(job.errors().isEmpty()); }
@Test public void shouldNotRerun_WhenJobConfigDoesNotExistAnymore_ForRunMultipleInstance() { Date old = new DateTime().minusDays(2).toDate(); StageConfig stageConfig = StageConfigMother.custom("dev", "rails", "java"); JobConfig railsConfig = stageConfig.getJobs().getJob(new CaseInsensitiveString("rails")); railsConfig.setRunInstanceCount(3); DefaultSchedulingContext schedulingContext = new DefaultSchedulingContext("loser", new Agents()); RunMultipleInstance.CounterBasedJobNameGenerator jobNameGenerator = new RunMultipleInstance.CounterBasedJobNameGenerator(CaseInsensitiveString.str(railsConfig.name())); JobInstances jobs = instanceFactory.createJobInstance(new CaseInsensitiveString("dev"), railsConfig, schedulingContext, new TimeProvider(), jobNameGenerator); Stage stage = createStageInstance(old, jobs); Stage newStage = null; CannotRerunJobException exception = null; try { newStage = instanceFactory.createStageForRerunOfJobs(stage, a("rails-runInstance-1"), schedulingContext, StageConfigMother.custom("dev", "java"), new TimeProvider(), "md5"); fail("should not schedule when job config does not exist anymore"); } catch (CannotRerunJobException e) { exception = e; } assertThat(exception.getJobName(), is("rails")); assertThat(exception.getInformation(), is("Configuration for job doesn't exist.")); assertThat(newStage, is(nullValue())); }