jenkins.model.GlobalConfiguration Java Examples

@Before
public void setupJenkins() throws IOException {
    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);
    assertThat(globalConfig, is(notNullValue()));
    VaultConfiguration vaultConfig = new VaultConfiguration();
    vaultConfig.setVaultUrl("http://global-vault-url.com");
    vaultConfig.setVaultCredentialId(GLOBAL_CREDENTIALS_ID_1);
    vaultConfig.setFailIfNotFound(false);
    vaultConfig.setEngineVersion(GLOBAL_ENGINE_VERSION_2);
    vaultConfig.setVaultNamespace("mynamespace");
    vaultConfig.setTimeout(TIMEOUT);
    globalConfig.setConfiguration(vaultConfig);

    globalConfig.save();

    GLOBAL_CREDENTIAL_1 = createTokenCredential(GLOBAL_CREDENTIALS_ID_1);
    GLOBAL_CREDENTIAL_2 = createTokenCredential(GLOBAL_CREDENTIALS_ID_2);

    SystemCredentialsProvider.getInstance()
        .setDomainCredentialsMap(Collections.singletonMap(Domain.global(), Arrays
            .asList(GLOBAL_CREDENTIAL_1, GLOBAL_CREDENTIAL_2)));

    this.project = jenkins.createFreeStyleProject("test");
}
 

private void updateUserApproval(User user, boolean approved) {
    String message;
    boolean oldStatus = user.isApproved();
    if (approved) {
        user.approve();
        message = String.valueOf(GlobalConfiguration.all().get(TelegramBotGlobalConfiguration.class)
                .getBotStrings().get("message.approved"));
    } else {
        user.unapprove();
        message = String.valueOf(GlobalConfiguration.all().get(TelegramBotGlobalConfiguration.class)
                .getBotStrings().get("message.unapproved"));
    }

    if (oldStatus != user.isApproved()) {
        TelegramBotRunner.getInstance().getBot().sendMessage(user.getId(), message);
    }
}
 

@Test
@ConfiguredWithCode("SeedJobTest_withSecurityConfig.yml")
@Envs(
    @Env(name = "SEED_JOB_FOLDER_FILE_PATH", value = ".")
)
public void configure_seed_job_with_security_config() throws Exception {
    final Jenkins jenkins = Jenkins.get();

    final GlobalJobDslSecurityConfiguration dslSecurity = GlobalConfiguration.all()
        .get(GlobalJobDslSecurityConfiguration.class);
    assertNotNull(dslSecurity);
    assertThat("ScriptSecurity", dslSecurity.isUseScriptSecurity(), is(false));

    FreeStyleProject seedJobWithSecurityConfig = (FreeStyleProject) jenkins.getItem("seedJobWithSecurityConfig");
    assertNotNull(seedJobWithSecurityConfig);

    assertTrue(seedJobWithSecurityConfig.isInQueue());
    FreeStyleBuild freeStyleBuild = j.buildAndAssertSuccess(seedJobWithSecurityConfig);
    j.assertLogContains("Processing DSL script testJob2.groovy", freeStyleBuild);
    j.assertLogContains("Added items:", freeStyleBuild);
    j.assertLogContains("GeneratedJob{name='testJob2'}", freeStyleBuild);
}
 

@Test
@ConfiguredWithReadme("sonarqube/README.md")
public void configure_sonar_globalconfig() throws Exception {

    final SonarGlobalConfiguration configuration = GlobalConfiguration.all().get(SonarGlobalConfiguration.class);
    assertTrue(configuration.isBuildWrapperEnabled());
    final SonarInstallation installation = configuration.getInstallations()[0];
    assertEquals("TEST", installation.getName());
    assertEquals("http://url:9000", installation.getServerUrl());
    assertEquals("token", installation.getServerAuthenticationToken());
    assertEquals("mojoVersion", installation.getMojoVersion());
    assertEquals("additionalAnalysisProperties", installation.getAdditionalAnalysisProperties());
    final TriggersConfig triggers = installation.getTriggers();
    assertTrue(triggers.isSkipScmCause());
    assertTrue(triggers.isSkipUpstreamCause());
    assertEquals("envVar", triggers.getEnvVar());
}
 

@NonNull
public static GlobalVaultConfiguration get() {
    GlobalVaultConfiguration instance = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);
    if (instance == null) {
        throw new IllegalStateException();
    }
    return instance;
}
 

public Set<User> getApprovedUsers() {
    if (GlobalConfiguration.all().get(TelegramBotGlobalConfiguration.class).getApprovalType() == UserApprover.ApprovalType.ALL) {
        return users.stream().collect(Collectors.toSet());
    }

    return users.stream()
            .filter(User::isApproved)
            .collect(Collectors.toSet());
}
 

@Test
public void shouldFailIfCredentialsNotConfigured() throws Exception {
    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);
    assertThat(globalConfig, is(notNullValue()));
    VaultConfiguration vaultConfig = new VaultConfiguration();
    vaultConfig.setVaultUrl("http://global-vault-url.com");
    vaultConfig.setFailIfNotFound(false);
    vaultConfig.setVaultNamespace("mynamespace");
    vaultConfig.setTimeout(TIMEOUT);

    globalConfig.setConfiguration(vaultConfig);

    globalConfig.save();

    List<VaultSecret> secrets = standardSecrets();

    VaultBuildWrapper vaultBuildWrapper = new VaultBuildWrapper(secrets);
    VaultAccessor mockAccessor = mockVaultAccessor(GLOBAL_ENGINE_VERSION_2);
    vaultBuildWrapper.setVaultAccessor(mockAccessor);

    this.project.getBuildWrappersList().add(vaultBuildWrapper);
    this.project.getBuildersList().add(echoSecret());

    FreeStyleBuild build = this.project.scheduleBuild2(0).get();

    jenkins.assertBuildStatus(Result.FAILURE, build);
    VaultConfig config = new VaultConfig().address(anyString());
    mockAccessor.setConfig(config);
    mockAccessor.setCredential(any(VaultCredential.class));
    verify(mockAccessor, times(0)).init();
    verify(mockAccessor, times(0)).read(anyString(), anyInt());
    jenkins.assertLogContains(
        "The credential id was not configured - please specify the credentials to use.", build);
}
 

@Test
public void shouldFailIfUrlNotConfigured() throws Exception {
    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);
    assertThat(globalConfig, is(notNullValue()));
    VaultConfiguration vaultConfig = new VaultConfiguration();
    vaultConfig.setVaultCredentialId(GLOBAL_CREDENTIALS_ID_2);
    vaultConfig.setFailIfNotFound(false);
    vaultConfig.setVaultNamespace("mynamespace");
    vaultConfig.setTimeout(TIMEOUT);
    globalConfig.setConfiguration(vaultConfig);

    globalConfig.save();

    List<VaultSecret> secrets = standardSecrets();

    VaultBuildWrapper vaultBuildWrapper = new VaultBuildWrapper(secrets);
    VaultAccessor mockAccessor = mockVaultAccessor(GLOBAL_ENGINE_VERSION_2);
    vaultBuildWrapper.setVaultAccessor(mockAccessor);

    this.project.getBuildWrappersList().add(vaultBuildWrapper);
    this.project.getBuildersList().add(echoSecret());

    FreeStyleBuild build = this.project.scheduleBuild2(0).get();

    jenkins.assertBuildStatus(Result.FAILURE, build);
    VaultConfig config = new VaultConfig().address(anyString());
    mockAccessor.setConfig(config);
    mockAccessor.setCredential(any(VaultCredential.class));

    verify(mockAccessor, times(0)).init();
    verify(mockAccessor, times(0)).read(anyString(), anyInt());
    jenkins.assertLogContains(
        "The vault url was not configured - please specify the vault url to use.", build);
}
 

@Before
public void setUp() throws IOException {
    MockitoAnnotations.initMocks(this);
    jobConfigData = new JobConfigData();
    jobConfigurationService = new JobConfigurationService();
    jobExecutionService = new JobExecutionService();
    globalConfigDataForSonarInstance = new GlobalConfigDataForSonarInstance();
    builderDescriptor = new QGBuilderDescriptor(jobExecutionService, jobConfigurationService);
    qgBuilder = new QGBuilder(jobConfigData, buildDecision, jobExecutionService, jobConfigurationService, globalConfigDataForSonarInstance);
    globalConfig = GlobalConfiguration.all().get(GlobalConfig.class);
    freeStyleProject = jenkinsRule.createFreeStyleProject("freeStyleProject");
    freeStyleProject.getBuildersList().add(qgBuilder);
    globalConfigDataForSonarInstanceList = new ArrayList<>();
}
 

@Before
public void setUp() throws IOException {
    MockitoAnnotations.initMocks(this);
    jobConfigData = new JobConfigData();
    jobExecutionService = new JobExecutionService();
    globalConfigDataForSonarInstance = new GlobalConfigDataForSonarInstance();
    publisher = new QGPublisher(jobConfigData, buildDecision, jobExecutionService, jobConfigurationService, globalConfigDataForSonarInstance);
    builder = new QGBuilder(jobConfigData, buildDecision, jobExecutionService, jobConfigurationService, globalConfigDataForSonarInstance);
    globalConfig = GlobalConfiguration.all().get(GlobalConfig.class);
    freeStyleProject = jenkinsRule.createFreeStyleProject("freeStyleProject");
    freeStyleProject.getBuildersList().add(builder);
    freeStyleProject.getPublishersList().add(publisher);
    globalConfigDataForSonarInstanceList = new ArrayList<>();
}
 

@Test
public void shouldFailIfNoConfigurationExists() throws Exception {
    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);
    assertThat(globalConfig, is(notNullValue()));
    globalConfig.setConfiguration(null);

    globalConfig.save();
    List<VaultSecret> secrets = standardSecrets();

    VaultBuildWrapper vaultBuildWrapper = new VaultBuildWrapper(secrets);
    VaultAccessor mockAccessor = mockVaultAccessor(GLOBAL_ENGINE_VERSION_2);
    vaultBuildWrapper.setVaultAccessor(mockAccessor);

    this.project.getBuildWrappersList().add(vaultBuildWrapper);
    this.project.getBuildersList().add(echoSecret());

    FreeStyleBuild build = this.project.scheduleBuild2(0).get();

    jenkins.assertBuildStatus(Result.FAILURE, build);
    VaultConfig config = new VaultConfig().address(anyString());
    mockAccessor.setConfig(config);
    mockAccessor.setCredential(any(VaultCredential.class));
    verify(mockAccessor, times(0)).init();
    verify(mockAccessor, times(0)).read(anyString(), anyInt());
    jenkins
        .assertLogContains("No configuration found - please configure the VaultPlugin.", build);
}
 

@Test
@Issue("JENKINS-57604")
@ConfiguredWithCode("GitTest.yml")
public void checkAssemblaWebIsLoaded() throws Exception {
    final Jenkins jenkins = Jenkins.get();
    final GlobalLibraries libs =  jenkins.getExtensionList(GlobalConfiguration.class)
            .get(GlobalLibraries.class);

    LibraryConfiguration lib = libs.getLibraries().get(0);
    SCMRetriever retriever = (SCMRetriever) lib.getRetriever();
    GitSCM scm = (GitSCM) retriever.getScm();
    AssemblaWeb browser = (AssemblaWeb)scm.getBrowser();
    assertEquals("assembla.acmecorp.com", browser.getRepoUrl());
}
 

@Test
public void shouldFailIfCredentialsDoNotExist() throws Exception {
    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);
    assertThat(globalConfig, is(notNullValue()));
    VaultConfiguration vaultConfig = new VaultConfiguration();
    vaultConfig.setVaultUrl("http://example.com");
    vaultConfig.setVaultCredentialId("some-made-up-ID");
    vaultConfig.setFailIfNotFound(false);
    vaultConfig.setVaultNamespace("mynamespace");
    vaultConfig.setTimeout(TIMEOUT);
    globalConfig.setConfiguration(vaultConfig);

    globalConfig.save();

    List<VaultSecret> secrets = standardSecrets();

    VaultBuildWrapper vaultBuildWrapper = new VaultBuildWrapper(secrets);
    VaultAccessor mockAccessor = mockVaultAccessor(GLOBAL_ENGINE_VERSION_2);
    vaultBuildWrapper.setVaultAccessor(mockAccessor);

    this.project.getBuildWrappersList().add(vaultBuildWrapper);
    this.project.getBuildersList().add(echoSecret());

    FreeStyleBuild build = this.project.scheduleBuild2(0).get();

    jenkins.assertBuildStatus(Result.FAILURE, build);
    VaultConfig config = new VaultConfig().address(anyString());
    mockAccessor.setConfig(config);
    mockAccessor.setCredential(any(VaultCredential.class));
    verify(mockAccessor, times(0)).init();
    verify(mockAccessor, times(0)).read(anyString(), anyInt());
    jenkins.assertLogContains("CredentialsUnavailableException", build);
}
 

@Test
@ConfiguredWithReadme("github/README.md")
public void configure_github() throws Exception {

    final GitHubPluginConfig configuration = GlobalConfiguration.all().get(GitHubPluginConfig.class);
    assertThat(configuration.getConfigs(), hasSize(1));

    GitHubServerConfig config = configuration.getConfigs().get(0);
    assertThat(config.getApiUrl(), is("https://github.domain.local/api/v3"));
    assertThat(config.getCredentialsId(), is("[GitHubEEUser]"));
    assertThat(config.getName(), is("InHouse GitHub EE"));
    assertTrue(config.isManageHooks());

}
 

private List<String> getStandardConfig() {
    List<String> configParameters = getBundledCasCURIs();
    CasCGlobalConfig casc = GlobalConfiguration.all().get(CasCGlobalConfig.class);
    String cascPath = casc != null ? casc.getConfigurationPath() : null;

    String configParameter = System.getProperty(
            CASC_JENKINS_CONFIG_PROPERTY,
            System.getenv(CASC_JENKINS_CONFIG_ENV)
    );

    // We prefer to rely on environment variable over global config
    if (StringUtils.isNotBlank(cascPath) && StringUtils.isBlank(configParameter)) {
        configParameter = cascPath;
    }

    if (configParameter == null) {
        String fullPath = Jenkins.get().getRootDir() + File.separator + DEFAULT_JENKINS_YAML_PATH;
        if (Files.exists(Paths.get(fullPath))) {
            configParameter = fullPath;
        }
    }

    if (configParameter != null) {
        // Add external config parameter
        configParameters.add(configParameter);
    }

    if (configParameters.isEmpty()) {
        LOGGER.log(Level.FINE, "No configuration set nor default config file");
    }
    return configParameters;
}
 

@RequirePOST
@Restricted(NoExternalUse.class)
public void doReplace(StaplerRequest request, StaplerResponse response) throws Exception {
    if (!Jenkins.get().hasPermission(Jenkins.ADMINISTER)) {
        response.sendError(HttpServletResponse.SC_FORBIDDEN);
        return;
    }
    String newSource = request.getParameter("_.newSource");
    String normalizedSource = Util.fixEmptyAndTrim(newSource);
    File file = new File(Util.fixNull(normalizedSource));
    if (file.exists() || ConfigurationAsCode.isSupportedURI(normalizedSource)) {
        List<String> candidatePaths = Collections.singletonList(normalizedSource);
        List<YamlSource> candidates = getConfigFromSources(candidatePaths);
        if (canApplyFrom(candidates)) {
            sources = candidatePaths;
            configureWith(getConfigFromSources(getSources()));
            CasCGlobalConfig config = GlobalConfiguration.all().get(CasCGlobalConfig.class);
            if (config != null) {
                config.setConfigurationPath(normalizedSource);
                config.save();
            }
            LOGGER.log(Level.FINE, "Replace configuration with: " + normalizedSource);
        } else {
            LOGGER.log(Level.WARNING, "Provided sources could not be applied");
            // todo: show message in UI
        }
    } else {
        LOGGER.log(Level.FINE, "No such source exists, applying default");
        // May be do nothing instead?
        configure();
    }
    response.sendRedirect("");
}
 

@Before
public void setupJenkins() throws IOException {
    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);

    VaultConfiguration vaultConfig = new VaultConfiguration();
    vaultConfig.setVaultUrl("http://global-vault-url.com");
    vaultConfig.setVaultCredentialId(GLOBAL_CREDENTIALS_ID_1);
    vaultConfig.setFailIfNotFound(false);
    vaultConfig.setVaultNamespace("mynamespace");
    vaultConfig.setTimeout(TIMEOUT);

    globalConfig.setConfiguration(vaultConfig);
    globalConfig.save();

    FOLDER_1_CREDENTIAL = createTokenCredential(FOLDER_1_CREDENTIALS_ID);
    FOLDER_2_CREDENTIAL = createTokenCredential(FOLDER_2_CREDENTIALS_ID);

    FolderCredentialsProvider.FolderCredentialsProperty folder1CredProperty = new FolderCredentialsProvider.FolderCredentialsProperty(
        new DomainCredentials[]{
            new DomainCredentials(Domain.global(),
                Collections.singletonList(FOLDER_1_CREDENTIAL))});

    FolderCredentialsProvider.FolderCredentialsProperty folder2CredProperty = new FolderCredentialsProvider.FolderCredentialsProperty(
        new DomainCredentials[]{
            new DomainCredentials(Domain.global(),
                Collections.singletonList(FOLDER_2_CREDENTIAL))});

    GLOBAL_CREDENTIAL_1 = createTokenCredential(GLOBAL_CREDENTIALS_ID_1);
    GLOBAL_CREDENTIAL_2 = createTokenCredential(GLOBAL_CREDENTIALS_ID_2);

    SystemCredentialsProvider.getInstance()
        .setDomainCredentialsMap(Collections.singletonMap(Domain.global(), Arrays
            .asList(GLOBAL_CREDENTIAL_1, GLOBAL_CREDENTIAL_2)));

    this.folder1 = jenkins.createProject(Folder.class, "folder1");
    this.folder2 = jenkins.createProject(Folder.class, "folder2");

    folder1.addProperty(folder1CredProperty);
    folder2.addProperty(folder2CredProperty);

    projectInFolder1 = this.folder1.createProject(FreeStyleProject.class, "projectInFolder1");
    projectInFolder2 = this.folder2.createProject(FreeStyleProject.class, "projectInFolder2");
}
 

@Nullable
public static GlobalPipelineMavenConfig get() {
    return GlobalConfiguration.all().get(GlobalPipelineMavenConfig.class);
}
 

public static GlobalConfig get() {
    return ExtensionList.lookup(GlobalConfiguration.class).get(GlobalConfig.class);
}
 

public static GitHubConfiguration get() {
    return GlobalConfiguration.all().get(GitHubConfiguration.class);
}
 

@Nullable
public static JiraCloudPluginConfig get() {
    return GlobalConfiguration.all().get(JiraCloudPluginConfig.class);
}
 

@Override
public String call() throws IOException {
    Jenkins jenkins = Jenkins.get();

    String msg = String.format(
        "Retrieving vault secret path=%s key=%s engineVersion=%s",
        secretPath, secretKey, engineVersion);
    LOGGER.info(msg);

    GlobalVaultConfiguration globalConfig = GlobalConfiguration.all()
        .get(GlobalVaultConfiguration.class);

    if (globalConfig == null) {
        throw new IllegalStateException("Vault plugin has not been configured.");
    }

    ExtensionList<VaultBuildWrapper.DescriptorImpl> extensionList = jenkins
        .getExtensionList(VaultBuildWrapper.DescriptorImpl.class);
    VaultBuildWrapper.DescriptorImpl descriptor = extensionList.get(0);

    VaultConfiguration configuration = globalConfig.getConfiguration();

    if (descriptor == null || configuration == null) {
        throw new IllegalStateException("Vault plugin has not been configured.");
    }

    try {
        SslConfig sslConfig = new SslConfig()
            .verify(configuration.isSkipSslVerification())
            .build();

        VaultConfig vaultConfig = new VaultConfig()
            .address(configuration.getVaultUrl())
            .sslConfig(sslConfig)
            .engineVersion(engineVersion);

        if (isNotEmpty(configuration.getVaultNamespace())) {
            vaultConfig.nameSpace(configuration.getVaultNamespace());
        }

        if (isNotEmpty(configuration.getPrefixPath())) {
            vaultConfig.prefixPath(configuration.getPrefixPath());
        }

        VaultCredential vaultCredential = configuration.getVaultCredential();
        if (vaultCredential == null) vaultCredential = retrieveVaultCredentials(configuration.getVaultCredentialId());

        VaultAccessor vaultAccessor = new VaultAccessor(vaultConfig, vaultCredential);
        vaultAccessor.setMaxRetries(configuration.getMaxRetries());
        vaultAccessor.setRetryIntervalMilliseconds(configuration.getRetryIntervalMilliseconds());
        vaultAccessor.init();

        Map<String, String> values = vaultAccessor.read(secretPath, engineVersion).getData();

        if (!values.containsKey(secretKey)) {
            String message = String.format(
                "Key %s could not be found in path %s",
                secretKey, secretPath);
            throw new VaultPluginException(message);
        }

        return values.get(secretKey);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

public static SetupConfig get() {
    return GlobalConfiguration.all().get(SetupConfig.class);
}
 

public GlobalConfig get() {
  return GlobalConfiguration.all().get(GlobalConfig.class);
}
 

public static GlobalItemStorage get() {
    return GlobalConfiguration.all().get(GlobalItemStorage.class);
}
 

private GlobalJobDslSecurityConfiguration getGlobalJobDslSecurityConfiguration() {
    final GlobalJobDslSecurityConfiguration dslSecurity = GlobalConfiguration.all()
        .get(GlobalJobDslSecurityConfiguration.class);
    assertNotNull(dslSecurity);
    return dslSecurity;
}
 

public static GlobalKafkaConfiguration get() {
    return GlobalConfiguration.all().getInstance(GlobalKafkaConfiguration.class);
}
 

public GlobalConfig getGlobalConfigData() {

        GlobalConfig globalConfig = GlobalConfiguration.all().get(GlobalConfig.class);

        if (globalConfig == null) {
            return new GlobalConfig();
        }

        return globalConfig;
    }
 

/**
 * Returns this singleton instance.
 *
 * @return the singleton.
 */
public static ViolationsToGitHubConfiguration get() {
  return GlobalConfiguration.all().get(ViolationsToGitHubConfiguration.class);
}
 

/**
 * Convenience method to get the configuration object
 *
 * @return the configuration object
 */
public static BuildStatusConfig get() {
    return GlobalConfiguration.all().get(BuildStatusConfig.class);
}