SONAR-13214 Remove org.sonar.api.config.Settings from the API

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/Xoo.java

  */
 package org.sonar.xoo;
 
-import java.util.Arrays;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.Configuration;
 import org.sonar.api.resources.Language;
 
 public class Xoo implements Language {
   public static final String FILE_SUFFIXES_KEY = "sonar.xoo.file.suffixes";
   public static final String DEFAULT_FILE_SUFFIXES = ".xoo";
 
-  private final Settings settings;
+  private final Configuration config;
 
-  public Xoo(Settings settings) {
-    this.settings = settings;
+  public Xoo(Configuration config) {
+    this.config = config;
   }
 
   @Override
 
   @Override
   public String[] getFileSuffixes() {
-    return Arrays.stream(settings.getStringArray(FILE_SUFFIXES_KEY)).filter(s -> s != null && !s.trim().isEmpty()).toArray(String[]::new);
+    return config.getStringArray(FILE_SUFFIXES_KEY);
   }
 }

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/XooPlugin.java

         .description("Comma-separated list of suffixes for files to analyze. To not filter, leave the list empty.")
         .subCategory("General")
         .onQualifiers(Qualifiers.PROJECT)
+        .multiValues(true)
         .build(),
       // Used by DuplicationsTest and IssueFilterOnCommonRulesTest. If not declared it is not returned by api/settings
       PropertyDefinition.builder("sonar.cpd.xoo.minimumTokens")

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/extensions/XooProjectBuilder.java

 import java.io.File;
 import org.sonar.api.batch.bootstrap.ProjectBuilder;
 import org.sonar.api.batch.bootstrap.ProjectDefinition;
-import org.sonar.api.config.Settings;
 
 public class XooProjectBuilder extends ProjectBuilder {
 
-  private Settings settings;
-
-  public XooProjectBuilder(Settings settings) {
-    this.settings = settings;
-  }
-
   @Override
   public void build(Context context) {
-    if (!settings.getBoolean("sonar.xoo.enableProjectBuilder")) {
+    if (!context.config().getBoolean("sonar.xoo.enableProjectBuilder").orElse(false)) {
       return;
     }
     ProjectDefinition root = context.projectReactor().getRoot();

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/rule/ChecksSensor.java

   @Override
   public void execute(SensorContext context) {
     Checks<Check> checks = checkFactory.create(XooRulesDefinition.XOO_REPOSITORY);
-    checks.addAnnotatedChecks(Check.ALL);
+    checks.addAnnotatedChecks((Object[]) Check.ALL);
     FilePredicates p = context.fileSystem().predicates();
     for (InputFile file : context.fileSystem().inputFiles(p.and(p.hasLanguages(Xoo.KEY), p.hasType(Type.MAIN)))) {
       for (Check check : checks.all()) {

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/rule/CreateIssueByInternalKeySensor.java

 
   private static void createIssues(InputFile file, SensorContext context) {
     ActiveRule rule = context.activeRules().findByInternalKey(XooRulesDefinition.XOO_REPOSITORY,
-      context.settings().getString(INTERNAL_KEY_PROPERTY));
+      context.config().get(INTERNAL_KEY_PROPERTY).orElse(null));
     if (rule != null) {
       NewIssue newIssue = context.newIssue();
       newIssue

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/rule/HasTagSensor.java

             NewIssue newIssue = context.newIssue();
             newIssue
               .forRule(ruleKey)
-              .gap(context.settings().getDouble(EFFORT_TO_FIX_PROPERTY))
+              .gap(context.config().getDouble(EFFORT_TO_FIX_PROPERTY).orElse(null))
               .at(newIssue.newLocation()
                 .on(inputFile)
                 .at(inputFile.newRange(lineCounter[0], startIndex, lineCounter[0], startIndex + tag.length())))

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/rule/OneIssuePerLineSensor.java

 
   private void createIssues(InputFile file, SensorContext context, String repo) {
     RuleKey ruleKey = RuleKey.of(repo, RULE_KEY);
-    String severity = context.settings().getString(FORCE_SEVERITY_PROPERTY);
+    String severity = context.config().get(FORCE_SEVERITY_PROPERTY).orElse(null);
     for (int line = 1; line <= file.lines(); line++) {
       NewIssue newIssue = context.newIssue();
       newIssue
           .message("This issue is generated on each line"))
         .overrideSeverity(severity != null ? Severity.valueOf(severity) : null);
       if (context.getSonarQubeVersion().isGreaterThanOrEqual(Version.create(5, 5))) {
-        newIssue.gap(context.settings().getDouble(EFFORT_TO_FIX_PROPERTY));
+        newIssue.gap(context.config().getDouble(EFFORT_TO_FIX_PROPERTY).orElse(null));
       } else {
-        newIssue.gap(context.settings().getDouble(EFFORT_TO_FIX_PROPERTY));
+        newIssue.gap(context.config().getDouble(EFFORT_TO_FIX_PROPERTY).orElse(null));
       }
       newIssue.save();
     }

plugins/sonar-xoo-plugin/src/main/java/org/sonar/xoo/rule/RandomAccessSensor.java

 
   @Override
   public void execute(SensorContext context) {
-    File f = new File(context.settings().getString(SONAR_XOO_RANDOM_ACCESS_ISSUE_PATHS));
+    File f = new File(context.config().get(SONAR_XOO_RANDOM_ACCESS_ISSUE_PATHS).orElseThrow(() -> new IllegalStateException("Required property")));
     FileSystem fs = context.fileSystem();
     FilePredicates p = fs.predicates();
     try {

server/sonar-auth-ldap/src/main/java/org/sonar/auth/ldap/LdapContextFactory.java

 import javax.security.auth.login.LoginContext;
 import javax.security.auth.login.LoginException;
 import org.apache.commons.lang.StringUtils;
-import org.sonar.api.config.Settings;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 
   private final String realm;
   private final String referral;
 
-  public LdapContextFactory(Settings settings, String settingsPrefix, String ldapUrl) {
-    this.authentication = StringUtils.defaultString(settings.getString(settingsPrefix + ".authentication"), DEFAULT_AUTHENTICATION);
-    this.factory = StringUtils.defaultString(settings.getString(settingsPrefix + ".contextFactoryClass"), DEFAULT_FACTORY);
-    this.realm = settings.getString(settingsPrefix + ".realm");
+  public LdapContextFactory(org.sonar.api.config.Configuration config, String settingsPrefix, String ldapUrl) {
+    this.authentication = StringUtils.defaultString(config.get(settingsPrefix + ".authentication").orElse(null), DEFAULT_AUTHENTICATION);
+    this.factory = StringUtils.defaultString(config.get(settingsPrefix + ".contextFactoryClass").orElse(null), DEFAULT_FACTORY);
+    this.realm = config.get(settingsPrefix + ".realm").orElse(null);
     this.providerUrl = ldapUrl;
-    this.startTLS = settings.getBoolean(settingsPrefix + ".StartTLS");
-    this.username = settings.getString(settingsPrefix + ".bindDn");
-    this.password = settings.getString(settingsPrefix + ".bindPassword");
-    this.referral = getReferralsMode(settings, settingsPrefix + ".followReferrals");
+    this.startTLS = config.getBoolean(settingsPrefix + ".StartTLS").orElse(false);
+    this.username = config.get(settingsPrefix + ".bindDn").orElse(null);
+    this.password = config.get(settingsPrefix + ".bindPassword").orElse(null);
+    this.referral = getReferralsMode(config, settingsPrefix + ".followReferrals");
   }
 
   /**
     return referral;
   }
 
-  private static String getReferralsMode(Settings settings, String followReferralsSettingKey) {
-    if (settings.hasKey(followReferralsSettingKey)) {
-      return settings.getBoolean(followReferralsSettingKey) ? REFERRALS_FOLLOW_MODE : REFERRALS_IGNORE_MODE;
-    }
+  private static String getReferralsMode(org.sonar.api.config.Configuration config, String followReferralsSettingKey) {
     // By default follow referrals
-    return REFERRALS_FOLLOW_MODE;
+    return config.getBoolean(followReferralsSettingKey).orElse(true) ? REFERRALS_FOLLOW_MODE : REFERRALS_IGNORE_MODE;
   }
 
   @Override

server/sonar-auth-ldap/src/main/java/org/sonar/auth/ldap/LdapGroupMapping.java

 import javax.naming.directory.Attribute;
 import javax.naming.directory.SearchResult;
 import org.apache.commons.lang.StringUtils;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.Configuration;
 
 /**
  * @author Evgeny Mandrikov
   /**
    * Constructs mapping from Sonar settings.
    */
-  public LdapGroupMapping(Settings settings, String settingsPrefix) {
-    this.baseDn = settings.getString(settingsPrefix + ".group.baseDn");
-    this.idAttribute = StringUtils.defaultString(settings.getString(settingsPrefix + ".group.idAttribute"), DEFAULT_ID_ATTRIBUTE);
+  public LdapGroupMapping(Configuration config, String settingsPrefix) {
+    this.baseDn = config.get(settingsPrefix + ".group.baseDn").orElse(null);
+    this.idAttribute = StringUtils.defaultString(config.get(settingsPrefix + ".group.idAttribute").orElse(null), DEFAULT_ID_ATTRIBUTE);
 
-    String req = StringUtils.defaultString(settings.getString(settingsPrefix + ".group.request"), DEFAULT_REQUEST);
+    String req = StringUtils.defaultString(config.get(settingsPrefix + ".group.request").orElse(null), DEFAULT_REQUEST);
     this.requiredUserAttributes = StringUtils.substringsBetween(req, "{", "}");
     for (int i = 0; i < requiredUserAttributes.length; i++) {
       req = StringUtils.replace(req, "{" + requiredUserAttributes[i] + "}", "{" + i + "}");

server/sonar-auth-ldap/src/main/java/org/sonar/auth/ldap/LdapSettingsManager.java

 import java.util.List;
 import java.util.Map;
 import org.apache.commons.lang.StringUtils;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.Configuration;
 import org.sonar.api.server.ServerSide;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
   private static final String LDAP_SERVERS_PROPERTY = "ldap.servers";
   private static final String LDAP_PROPERTY_PREFIX = "ldap";
   private static final String DEFAULT_LDAP_SERVER_KEY = "<default>";
-  private final Settings settings;
+  private final Configuration config;
   private final LdapAutodiscovery ldapAutodiscovery;
   private Map<String, LdapUserMapping> userMappings = null;
   private Map<String, LdapGroupMapping> groupMappings = null;
   /**
    * Create an instance of the settings manager.
    *
-   * @param settings The settings to use.
+   * @param config The config to use.
    */
-  public LdapSettingsManager(Settings settings, LdapAutodiscovery ldapAutodiscovery) {
-    this.settings = settings;
+  public LdapSettingsManager(Configuration config, LdapAutodiscovery ldapAutodiscovery) {
+    this.config = config;
     this.ldapAutodiscovery = ldapAutodiscovery;
   }
 
     if (userMappings == null) {
       // Use linked hash map to preserve order
       userMappings = new LinkedHashMap<>();
-      String[] serverKeys = settings.getStringArray(LDAP_SERVERS_PROPERTY);
+      String[] serverKeys = config.getStringArray(LDAP_SERVERS_PROPERTY);
       if (serverKeys.length > 0) {
         for (String serverKey : serverKeys) {
-          LdapUserMapping userMapping = new LdapUserMapping(settings, LDAP_PROPERTY_PREFIX + "." + serverKey);
+          LdapUserMapping userMapping = new LdapUserMapping(config, LDAP_PROPERTY_PREFIX + "." + serverKey);
           if (StringUtils.isNotBlank(userMapping.getBaseDn())) {
             LOG.info("User mapping for server {}: {}", serverKey, userMapping);
             userMappings.put(serverKey, userMapping);
         }
       } else {
         // Backward compatibility with single server configuration
-        LdapUserMapping userMapping = new LdapUserMapping(settings, LDAP_PROPERTY_PREFIX);
+        LdapUserMapping userMapping = new LdapUserMapping(config, LDAP_PROPERTY_PREFIX);
         if (StringUtils.isNotBlank(userMapping.getBaseDn())) {
           LOG.info("User mapping: {}", userMapping);
           userMappings.put(DEFAULT_LDAP_SERVER_KEY, userMapping);
     if (groupMappings == null) {
       // Use linked hash map to preserve order
       groupMappings = new LinkedHashMap<>();
-      String[] serverKeys = settings.getStringArray(LDAP_SERVERS_PROPERTY);
+      String[] serverKeys = config.getStringArray(LDAP_SERVERS_PROPERTY);
       if (serverKeys.length > 0) {
         for (String serverKey : serverKeys) {
-          LdapGroupMapping groupMapping = new LdapGroupMapping(settings, LDAP_PROPERTY_PREFIX + "." + serverKey);
+          LdapGroupMapping groupMapping = new LdapGroupMapping(config, LDAP_PROPERTY_PREFIX + "." + serverKey);
           if (StringUtils.isNotBlank(groupMapping.getBaseDn())) {
             LOG.info("Group mapping for server {}: {}", serverKey, groupMapping);
             groupMappings.put(serverKey, groupMapping);
         }
       } else {
         // Backward compatibility with single server configuration
-        LdapGroupMapping groupMapping = new LdapGroupMapping(settings, LDAP_PROPERTY_PREFIX);
+        LdapGroupMapping groupMapping = new LdapGroupMapping(config, LDAP_PROPERTY_PREFIX);
         if (StringUtils.isNotBlank(groupMapping.getBaseDn())) {
           LOG.info("Group mapping: {}", groupMapping);
           groupMappings.put(DEFAULT_LDAP_SERVER_KEY, groupMapping);
     if (contextFactories == null) {
       // Use linked hash map to preserve order
       contextFactories = new LinkedHashMap<>();
-      String[] serverKeys = settings.getStringArray(LDAP_SERVERS_PROPERTY);
+      String[] serverKeys = config.getStringArray(LDAP_SERVERS_PROPERTY);
       if (serverKeys.length > 0) {
         initMultiLdapConfiguration(serverKeys);
       } else {
   }
 
   private void initSimpleLdapConfiguration() {
-    String realm = settings.getString(LDAP_PROPERTY_PREFIX + ".realm");
+    String realm = config.get(LDAP_PROPERTY_PREFIX + ".realm").orElse(null);
     String ldapUrlKey = LDAP_PROPERTY_PREFIX + ".url";
-    String ldapUrl = settings.getString(ldapUrlKey);
+    String ldapUrl = config.get(ldapUrlKey).orElse(null);
     if (ldapUrl == null && realm != null) {
       LOG.warn("Auto-discovery feature is deprecated, please use '{}' to specify LDAP url", ldapUrlKey);
       List<LdapSrvRecord> ldapServers = ldapAutodiscovery.getLdapServers(realm);
       for (LdapSrvRecord ldapSrvRecord : ldapServers) {
         if (StringUtils.isNotBlank(ldapSrvRecord.getServerUrl())) {
           LOG.info("Detected server: {}", ldapSrvRecord.getServerUrl());
-          LdapContextFactory contextFactory = new LdapContextFactory(settings, LDAP_PROPERTY_PREFIX, ldapSrvRecord.getServerUrl());
+          LdapContextFactory contextFactory = new LdapContextFactory(config, LDAP_PROPERTY_PREFIX, ldapSrvRecord.getServerUrl());
           contextFactories.put(DEFAULT_LDAP_SERVER_KEY + index, contextFactory);
           index++;
         }
       if (StringUtils.isBlank(ldapUrl)) {
         throw new LdapException(String.format("The property '%s' is empty and no realm configured to try auto-discovery.", ldapUrlKey));
       }
-      LdapContextFactory contextFactory = new LdapContextFactory(settings, LDAP_PROPERTY_PREFIX, ldapUrl);
+      LdapContextFactory contextFactory = new LdapContextFactory(config, LDAP_PROPERTY_PREFIX, ldapUrl);
       contextFactories.put(DEFAULT_LDAP_SERVER_KEY, contextFactory);
     }
   }
 
   private void initMultiLdapConfiguration(String[] serverKeys) {
-    if (settings.hasKey("ldap.url") || settings.hasKey("ldap.realm")) {
+    if (config.hasKey("ldap.url") || config.hasKey("ldap.realm")) {
       throw new LdapException("When defining multiple LDAP servers with the property '" + LDAP_SERVERS_PROPERTY + "', "
         + "all LDAP properties must be linked to one of those servers. Please remove properties like 'ldap.url', 'ldap.realm', ...");
     }
     for (String serverKey : serverKeys) {
       String prefix = LDAP_PROPERTY_PREFIX + "." + serverKey;
       String ldapUrlKey = prefix + ".url";
-      String ldapUrl = settings.getString(ldapUrlKey);
+      String ldapUrl = config.get(ldapUrlKey).orElse(null);
       if (StringUtils.isBlank(ldapUrl)) {
         throw new LdapException(String.format("The property '%s' property is empty while it is mandatory.", ldapUrlKey));
       }
-      LdapContextFactory contextFactory = new LdapContextFactory(settings, prefix, ldapUrl);
+      LdapContextFactory contextFactory = new LdapContextFactory(config, prefix, ldapUrl);
       contextFactories.put(serverKey, contextFactory);
     }
   }

server/sonar-auth-ldap/src/main/java/org/sonar/auth/ldap/LdapUserMapping.java

 package org.sonar.auth.ldap;
 
 import org.apache.commons.lang.StringUtils;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.Configuration;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 
   /**
    * Constructs mapping from Sonar settings.
    */
-  public LdapUserMapping(Settings settings, String settingsPrefix) {
+  public LdapUserMapping(Configuration config, String settingsPrefix) {
     String usesrBaseDnSettingKey = settingsPrefix + ".user.baseDn";
-    String usersBaseDn = settings.getString(usesrBaseDnSettingKey);
+    String usersBaseDn = config.get(usesrBaseDnSettingKey).orElse(null);
     if (usersBaseDn == null) {
-      String realm = settings.getString(settingsPrefix + ".realm");
+      String realm = config.get(settingsPrefix + ".realm").orElse(null);
       if (realm != null) {
         LOG.warn("Auto-discovery feature is deprecated, please use '{}' to specify user search dn", usesrBaseDnSettingKey);
         usersBaseDn = LdapAutodiscovery.getDnsDomainDn(realm);
     }
 
     this.baseDn = usersBaseDn;
-    this.realNameAttribute = StringUtils.defaultString(settings.getString(settingsPrefix + ".user.realNameAttribute"), DEFAULT_NAME_ATTRIBUTE);
-    this.emailAttribute = StringUtils.defaultString(settings.getString(settingsPrefix + ".user.emailAttribute"), DEFAULT_EMAIL_ATTRIBUTE);
+    this.realNameAttribute = StringUtils.defaultString(config.get(settingsPrefix + ".user.realNameAttribute").orElse(null), DEFAULT_NAME_ATTRIBUTE);
+    this.emailAttribute = StringUtils.defaultString(config.get(settingsPrefix + ".user.emailAttribute").orElse(null), DEFAULT_EMAIL_ATTRIBUTE);
 
-    String req = StringUtils.defaultString(settings.getString(settingsPrefix + ".user.request"), DEFAULT_REQUEST);
+    String req = StringUtils.defaultString(config.get(settingsPrefix + ".user.request").orElse(null), DEFAULT_REQUEST);
     req = StringUtils.replace(req, "{login}", "{0}");
     this.request = req;
   }

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/KerberosTest.java

   @Test
   public void test() {
     MapSettings settings = configure();
-    LdapRealm ldapRealm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm ldapRealm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
 
     ldapRealm.init();
 
   public void wrong_bind_password() {
     MapSettings settings = configure()
       .setProperty("ldap.bindPassword", "wrong_bind_password");
-    LdapRealm ldapRealm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm ldapRealm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
     try {
       ldapRealm.init();
       Assert.fail();

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapAuthenticatorTest.java

   public void testNoConnection() {
     exampleServer.disableAnonymousAccess();
     try {
-      LdapSettingsManager settingsManager = new LdapSettingsManager(LdapSettingsFactory.generateAuthenticationSettings(exampleServer, null, LdapContextFactory.AUTH_METHOD_SIMPLE),
+      LdapSettingsManager settingsManager = new LdapSettingsManager(LdapSettingsFactory.generateAuthenticationSettings(exampleServer, null, LdapContextFactory.AUTH_METHOD_SIMPLE).asConfig(),
         new LdapAutodiscovery());
       LdapAuthenticator authenticator = new LdapAuthenticator(settingsManager.getContextFactories(), settingsManager.getUserMappings());
       authenticator.authenticate("godin", "secret1");
 
   @Test
   public void testSimple() {
-    LdapSettingsManager settingsManager = new LdapSettingsManager(LdapSettingsFactory.generateAuthenticationSettings(exampleServer, null, LdapContextFactory.AUTH_METHOD_SIMPLE),
+    LdapSettingsManager settingsManager = new LdapSettingsManager(LdapSettingsFactory.generateAuthenticationSettings(exampleServer, null, LdapContextFactory.AUTH_METHOD_SIMPLE).asConfig(),
       new LdapAutodiscovery());
     LdapAuthenticator authenticator = new LdapAuthenticator(settingsManager.getContextFactories(), settingsManager.getUserMappings());
 
   @Test
   public void testSimpleMultiLdap() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      LdapSettingsFactory.generateAuthenticationSettings(exampleServer, infosupportServer, LdapContextFactory.AUTH_METHOD_SIMPLE), new LdapAutodiscovery());
+      LdapSettingsFactory.generateAuthenticationSettings(exampleServer, infosupportServer, LdapContextFactory.AUTH_METHOD_SIMPLE).asConfig(), new LdapAutodiscovery());
     LdapAuthenticator authenticator = new LdapAuthenticator(settingsManager.getContextFactories(), settingsManager.getUserMappings());
 
     assertThat(authenticator.authenticate("godin", "secret1")).isTrue();
 
   @Test
   public void testSasl() {
-    LdapSettingsManager settingsManager = new LdapSettingsManager(LdapSettingsFactory.generateAuthenticationSettings(exampleServer, null, LdapContextFactory.AUTH_METHOD_CRAM_MD5),
+    LdapSettingsManager settingsManager = new LdapSettingsManager(LdapSettingsFactory.generateAuthenticationSettings(exampleServer, null, LdapContextFactory.AUTH_METHOD_CRAM_MD5).asConfig(),
       new LdapAutodiscovery());
     LdapAuthenticator authenticator = new LdapAuthenticator(settingsManager.getContextFactories(), settingsManager.getUserMappings());
 
   @Test
   public void testSaslMultipleLdap() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      LdapSettingsFactory.generateAuthenticationSettings(exampleServer, infosupportServer, LdapContextFactory.AUTH_METHOD_CRAM_MD5), new LdapAutodiscovery());
+      LdapSettingsFactory.generateAuthenticationSettings(exampleServer, infosupportServer, LdapContextFactory.AUTH_METHOD_CRAM_MD5).asConfig(), new LdapAutodiscovery());
     LdapAuthenticator authenticator = new LdapAuthenticator(settingsManager.getContextFactories(), settingsManager.getUserMappings());
 
     assertThat(authenticator.authenticate("godin", "secret1")).isTrue();

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapAutoDiscoveryWarningLogTest.java

   public void does_not_display_log_when_not_using_auto_discovery() {
     MapSettings settings = new MapSettings()
       .setProperty("ldap.url", server.getUrl());
-    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
     assertThat(realm.getName()).isEqualTo("LDAP");
 
     realm.init();
     LdapAutodiscovery ldapAutodiscovery = mock(LdapAutodiscovery.class);
     when(ldapAutodiscovery.getLdapServers("example.org")).thenReturn(singletonList(new LdapAutodiscovery.LdapSrvRecord(server.getUrl(), 1, 1)));
     // ldap.url setting is not set
-    LdapRealm realm = new LdapRealm(new LdapSettingsManager(new MapSettings().setProperty("ldap.realm", "example.org"),
+    LdapRealm realm = new LdapRealm(new LdapSettingsManager(new MapSettings().setProperty("ldap.realm", "example.org").asConfig(),
       ldapAutodiscovery));
 
     realm.init();
   public void display_warning_log_when_using_auto_discovery_to_detect_user_baseDn_on_single_server() {
     // ldap.user.baseDn setting is not set
     MapSettings settings = new MapSettings().setProperty("ldap.url", server.getUrl()).setProperty("ldap.realm", "example.org");
-    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
 
     realm.init();
 
       .setProperty("ldap.example.realm", "example.org")
       .setProperty("ldap.infosupport.url", server2.getUrl())
       .setProperty("ldap.infosupport.realm", "infosupport.org");
-    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
 
     realm.init();
 

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapGroupMappingTest.java

 
   @Test
   public void defaults() {
-    LdapGroupMapping groupMapping = new LdapGroupMapping(new MapSettings(), "ldap");
+    LdapGroupMapping groupMapping = new LdapGroupMapping(new MapSettings().asConfig(), "ldap");
 
     assertThat(groupMapping.getBaseDn()).isNull();
     assertThat(groupMapping.getIdAttribute()).isEqualTo("cn");
   public void custom_request() {
     MapSettings settings = new MapSettings()
       .setProperty("ldap.group.request", "(&(|(objectClass=posixGroup)(objectClass=groupOfUniqueNames))(|(memberUid={uid})(uniqueMember={dn})))");
-    LdapGroupMapping groupMapping = new LdapGroupMapping(settings, "ldap");
+    LdapGroupMapping groupMapping = new LdapGroupMapping(settings.asConfig(), "ldap");
 
     assertThat(groupMapping.getRequest()).isEqualTo("(&(|(objectClass=posixGroup)(objectClass=groupOfUniqueNames))(|(memberUid={0})(uniqueMember={1})))");
     assertThat(groupMapping.getRequiredUserAttributes()).isEqualTo(new String[] {"uid", "dn"});

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapGroupsProviderTest.java

   public void defaults() {
     MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, null);
 
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapGroupsProvider groupsProvider = new LdapGroupsProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings(), settingsManager.getGroupMappings());
     Collection<String> groups;
 
   public void defaultsMultipleLdap() {
     MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, infosupportServer);
 
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapGroupsProvider groupsProvider = new LdapGroupsProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings(), settingsManager.getGroupMappings());
 
     Collection<String> groups;
   public void posix() {
     MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, null);
     settings.setProperty("ldap.group.request", "(&(objectClass=posixGroup)(memberUid={uid}))");
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapGroupsProvider groupsProvider = new LdapGroupsProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings(), settingsManager.getGroupMappings());
 
     Collection<String> groups;
     MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, infosupportServer);
     settings.setProperty("ldap.example.group.request", "(&(objectClass=posixGroup)(memberUid={uid}))");
     settings.setProperty("ldap.infosupport.group.request", "(&(objectClass=posixGroup)(memberUid={uid}))");
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapGroupsProvider groupsProvider = new LdapGroupsProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings(), settingsManager.getGroupMappings());
 
     Collection<String> groups;
   public void mixed() {
     MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, infosupportServer);
     settings.setProperty("ldap.example.group.request", "(&(|(objectClass=groupOfUniqueNames)(objectClass=posixGroup))(|(uniqueMember={dn})(memberUid={uid})))");
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapGroupsProvider groupsProvider = new LdapGroupsProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings(), settingsManager.getGroupMappings());
 
     Collection<String> groups;
     MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, infosupportServer);
     settings.setProperty("ldap.example.group.request", "(&(|(objectClass=groupOfUniqueNames)(objectClass=posixGroup))(|(uniqueMember={dn})(memberUid={uid})))");
     settings.setProperty("ldap.infosupport.group.request", "(&(|(objectClass=groupOfUniqueNames)(objectClass=posixGroup))(|(uniqueMember={dn})(memberUid={uid})))");
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapGroupsProvider groupsProvider = new LdapGroupsProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings(), settingsManager.getGroupMappings());
 
     Collection<String> groups;

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapRealmTest.java

   public void normal() {
     MapSettings settings = new MapSettings()
       .setProperty("ldap.url", server.getUrl());
-    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
     assertThat(realm.getName()).isEqualTo("LDAP");
     realm.init();
     assertThat(realm.doGetAuthenticator()).isInstanceOf(LdapAuthenticator.class);
     MapSettings settings = new MapSettings()
       .setProperty("ldap.url", "ldap://no-such-host")
       .setProperty("ldap.group.baseDn", "cn=groups,dc=example,dc=org");
-    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings, new LdapAutodiscovery()));
+    LdapRealm realm = new LdapRealm(new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()));
     assertThat(realm.getName()).isEqualTo("LDAP");
     try {
       realm.init();

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapReferralsTest.java

 import javax.annotation.Nullable;
 import org.junit.ClassRule;
 import org.junit.Test;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.MapSettings;
 import org.sonar.auth.ldap.server.LdapServer;
 
 import static org.assertj.core.api.Assertions.assertThat;
   }
 
   private static Map<String, LdapContextFactory> createFactories(@Nullable String propertyKey, @Nullable String propertyValue) {
-    Settings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(server, null);
+    MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(server, null);
     if (propertyKey != null) {
       settings.setProperty(propertyKey, propertyValue);
     }
-    return new LdapSettingsManager(settings, new LdapAutodiscovery()).getContextFactories();
+    return new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery()).getContextFactories();
   }
 }

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapSearchTest.java

 
   @BeforeClass
   public static void init() {
-    contextFactories = new LdapSettingsManager(LdapSettingsFactory.generateSimpleAnonymousAccessSettings(server, null), new LdapAutodiscovery()).getContextFactories();
+    contextFactories = new LdapSettingsManager(LdapSettingsFactory.generateSimpleAnonymousAccessSettings(server, null).asConfig(), new LdapAutodiscovery()).getContextFactories();
   }
 
   @Test

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapSettingsManagerTest.java

 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
-import org.sonar.api.config.Settings;
 import org.sonar.api.config.internal.MapSettings;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
   @Test
   public void shouldFailWhenNoLdapUrl() {
-    Settings settings = generateMultipleLdapSettingsWithUserAndGroupMapping();
+    MapSettings settings = generateMultipleLdapSettingsWithUserAndGroupMapping();
     settings.removeProperty("ldap.example.url");
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
 
     thrown.expect(LdapException.class);
     thrown.expectMessage("The property 'ldap.example.url' property is empty while it is mandatory.");
 
   @Test
   public void shouldFailWhenMixingSingleAndMultipleConfiguration() {
-    Settings settings = generateMultipleLdapSettingsWithUserAndGroupMapping();
+    MapSettings settings = generateMultipleLdapSettingsWithUserAndGroupMapping();
     settings.setProperty("ldap.url", "ldap://foo");
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
 
     thrown.expect(LdapException.class);
     thrown
   @Test
   public void testContextFactoriesWithSingleLdap() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      generateSingleLdapSettingsWithUserAndGroupMapping(), new LdapAutodiscovery());
+      generateSingleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
     assertThat(settingsManager.getContextFactories().size()).isEqualTo(1);
   }
 
   @Test
   public void testContextFactoriesWithMultipleLdap() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      generateMultipleLdapSettingsWithUserAndGroupMapping(), new LdapAutodiscovery());
+      generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
     assertThat(settingsManager.getContextFactories().size()).isEqualTo(2);
     // We do it twice to make sure the settings keep the same.
     assertThat(settingsManager.getContextFactories().size()).isEqualTo(2);
     LdapSrvRecord ldap2 = new LdapSrvRecord("ldap://localhost:1899", 1, 1);
     when(ldapAutodiscovery.getLdapServers("example.org")).thenReturn(Arrays.asList(ldap1, ldap2));
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      generateAutodiscoverSettings(), ldapAutodiscovery);
+      generateAutodiscoverSettings().asConfig(), ldapAutodiscovery);
     assertThat(settingsManager.getContextFactories().size()).isEqualTo(2);
   }
 
     LdapAutodiscovery ldapAutodiscovery = mock(LdapAutodiscovery.class);
     when(ldapAutodiscovery.getLdapServers("example.org")).thenReturn(Collections.emptyList());
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      generateAutodiscoverSettings(), ldapAutodiscovery);
+      generateAutodiscoverSettings().asConfig(), ldapAutodiscovery);
 
     thrown.expect(LdapException.class);
     thrown.expectMessage("The property 'ldap.url' is empty and SonarQube is not able to auto-discover any LDAP server.");
   @Test
   public void testUserMappings() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      generateMultipleLdapSettingsWithUserAndGroupMapping(), new LdapAutodiscovery());
+      generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
     assertThat(settingsManager.getUserMappings().size()).isEqualTo(2);
     // We do it twice to make sure the settings keep the same.
     assertThat(settingsManager.getUserMappings().size()).isEqualTo(2);
   @Test
   public void testGroupMappings() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      generateMultipleLdapSettingsWithUserAndGroupMapping(), new LdapAutodiscovery());
+      generateMultipleLdapSettingsWithUserAndGroupMapping().asConfig(), new LdapAutodiscovery());
     assertThat(settingsManager.getGroupMappings().size()).isEqualTo(2);
     // We do it twice to make sure the settings keep the same.
     assertThat(settingsManager.getGroupMappings().size()).isEqualTo(2);
   @Test
   public void testEmptySettings() {
     LdapSettingsManager settingsManager = new LdapSettingsManager(
-      new MapSettings(), new LdapAutodiscovery());
+      new MapSettings().asConfig(), new LdapAutodiscovery());
 
     thrown.expect(LdapException.class);
     thrown.expectMessage("The property 'ldap.url' is empty and no realm configured to try auto-discovery.");

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapUserMappingTest.java

 
   @Test
   public void defaults() {
-    LdapUserMapping userMapping = new LdapUserMapping(new MapSettings(), "ldap");
+    LdapUserMapping userMapping = new LdapUserMapping(new MapSettings().asConfig(), "ldap");
     assertThat(userMapping.getBaseDn()).isNull();
     assertThat(userMapping.getRequest()).isEqualTo("(&(objectClass=inetOrgPerson)(uid={0}))");
     assertThat(userMapping.getRealNameAttribute()).isEqualTo("cn");
       .setProperty("ldap.user.baseDn", "cn=users")
       .setProperty("ldap.user.request", "(&(objectClass=user)(sAMAccountName={0}))");
 
-    LdapUserMapping userMapping = new LdapUserMapping(settings, "ldap");
+    LdapUserMapping userMapping = new LdapUserMapping(settings.asConfig(), "ldap");
     LdapSearch search = userMapping.createSearch(null, "tester");
     assertThat(search.getBaseDn()).isEqualTo("cn=users");
     assertThat(search.getRequest()).isEqualTo("(&(objectClass=user)(sAMAccountName={0}))");
       .setProperty("ldap.userObjectClass", "user")
       .setProperty("ldap.loginAttribute", "sAMAccountName");
 
-    LdapUserMapping userMapping = new LdapUserMapping(settings, "ldap");
+    LdapUserMapping userMapping = new LdapUserMapping(settings.asConfig(), "ldap");
     assertThat(userMapping.getBaseDn()).isEqualTo("dc=example,dc=org");
   }
 

server/sonar-auth-ldap/src/test/java/org/sonar/auth/ldap/LdapUsersProviderTest.java

 
 import org.junit.ClassRule;
 import org.junit.Test;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.security.UserDetails;
 import org.sonar.auth.ldap.server.LdapServer;
 
 
   @Test
   public void test() {
-    Settings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, infosupportServer);
-    LdapSettingsManager settingsManager = new LdapSettingsManager(settings, new LdapAutodiscovery());
+    MapSettings settings = LdapSettingsFactory.generateSimpleAnonymousAccessSettings(exampleServer, infosupportServer);
+    LdapSettingsManager settingsManager = new LdapSettingsManager(settings.asConfig(), new LdapAutodiscovery());
     LdapUsersProvider usersProvider = new LdapUsersProvider(settingsManager.getContextFactories(), settingsManager.getUserMappings());
 
     UserDetails details;

server/sonar-ce-task-projectanalysis/src/main/java/org/sonar/ce/task/projectanalysis/analysis/ProjectConfigurationFactory.java

 
 import org.sonar.api.ce.ComputeEngineSide;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.ConfigurationBridge;
 import org.sonar.db.DbClient;
 import org.sonar.db.component.BranchType;

server/sonar-ce-task-projectanalysis/src/test/java/org/sonar/ce/task/projectanalysis/issue/filter/IssueFilterTest.java

 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.ce.task.projectanalysis.component.Component;

server/sonar-ce-task/src/main/java/org/sonar/ce/task/setting/SettingsLoader.java

 
 import org.picocontainer.Startable;
 import org.sonar.api.ce.ComputeEngineSide;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.ce.task.container.EagerStart;
 import org.sonar.ce.task.container.TaskContainerImpl;
 import org.sonar.server.setting.ThreadLocalSettings;
 
 /**
  * Add this class as the first components in the {@link TaskContainerImpl}
- * to trigger loading of Thread local specific {@link org.sonar.api.config.Settings} in {@link ThreadLocalSettings}.
+ * to trigger loading of Thread local specific {@link Settings} in {@link ThreadLocalSettings}.
  */
 @EagerStart
 @ComputeEngineSide

server/sonar-db-core/src/main/java/org/sonar/db/DefaultDatabase.java

 import org.apache.commons.dbcp2.BasicDataSource;
 import org.apache.commons.dbcp2.BasicDataSourceFactory;
 import org.apache.commons.lang.StringUtils;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 import org.sonar.db.dialect.Dialect;

server/sonar-db-core/src/testFixtures/java/org/sonar/db/CoreTestDb.java

 import javax.sql.DataSource;
 import org.apache.commons.codec.digest.DigestUtils;
 import org.junit.AssumptionViolatedException;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;

server/sonar-db-dao/src/test/java/org/sonar/db/createdb/CreateDb.java

 import com.sonar.orchestrator.db.DatabaseFactory;
 import com.sonar.orchestrator.db.DefaultDatabase;
 import java.util.function.Consumer;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;

server/sonar-db-dao/src/testFixtures/java/org/sonar/db/OrchestratorSettingsUtils.java

 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang.text.StrSubstitutor;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 
 import static org.apache.commons.lang.StringUtils.isEmpty;
 

server/sonar-db-dao/src/testFixtures/java/org/sonar/db/SQDatabase.java

 import org.apache.ibatis.jdbc.ScriptRunner;
 import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarQubeSide;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.utils.System2;

server/sonar-db-dao/src/testFixtures/java/org/sonar/db/TestDbImpl.java

 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.lang.StringUtils;
 import org.junit.AssumptionViolatedException;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.db.dialect.H2;
 import org.sonar.process.logging.LogbackHelper;
 

server/sonar-server-common/src/main/java/org/sonar/server/config/ConfigurationProvider.java

 import org.picocontainer.injectors.ProviderAdapter;
 import org.sonar.api.config.Configuration;
 import org.sonar.api.config.PropertyDefinition;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 
 import static java.util.function.Function.identity;
 import static org.sonar.api.config.internal.MultivalueProperty.parseAsCsv;

server/sonar-server-common/src/main/java/org/sonar/server/setting/ChildSettings.java

 import java.util.Map;
 import java.util.Optional;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.ConfigurationBridge;
 
 import static java.util.Objects.requireNonNull;

server/sonar-server-common/src/main/java/org/sonar/server/setting/ThreadLocalSettings.java

 import org.apache.ibatis.exceptions.PersistenceException;
 import org.sonar.api.CoreProperties;
 import org.sonar.api.ce.ComputeEngineSide;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.config.PropertyDefinitions;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.server.ServerSide;
 import org.sonar.api.utils.System2;
 import org.sonar.core.util.SettingFormatter;

server/sonar-webserver-api/src/main/java/org/sonar/server/setting/ProjectConfigurationLoaderImpl.java

 import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.component.ComponentDto;

server/sonar-webserver-core/src/main/java/org/sonar/server/platform/PersistentSettings.java

 
 import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.property.PropertyDto;

server/sonar-webserver-core/src/main/java/org/sonar/server/platform/monitoring/SettingsSection.java

 import org.sonar.api.PropertyType;
 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.config.PropertyDefinitions;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.server.ServerSide;
 import org.sonar.process.systeminfo.Global;
 import org.sonar.process.systeminfo.SystemInfoSection;

server/sonar-webserver-core/src/test/java/org/sonar/server/notification/NotificationMediumTest.java

 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.sonar.api.config.PropertyDefinitions;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.notifications.Notification;
 import org.sonar.api.notifications.NotificationChannel;

server/sonar-webserver-core/src/test/java/org/sonar/server/platform/PersistentSettingsTest.java

 
 import org.junit.Rule;
 import org.junit.Test;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.utils.System2;
 import org.sonar.db.DbTester;

server/sonar-webserver-core/src/test/java/org/sonar/server/platform/monitoring/SettingsSectionTest.java

 import org.sonar.api.PropertyType;
 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.config.PropertyDefinitions;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.process.systeminfo.protobuf.ProtobufSystemInfo;
 

server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/CheckSecretKeyAction.java

  */
 package org.sonar.server.setting.ws;
 
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
 import org.sonar.api.server.ws.WebService;

server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/EncryptAction.java

  */
 package org.sonar.server.setting.ws;
 
-import org.sonar.api.config.Encryption;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Encryption;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
 import org.sonar.api.server.ws.WebService;

server/sonar-webserver-webapi/src/main/java/org/sonar/server/setting/ws/GenerateSecretKeyAction.java

  */
 package org.sonar.server.setting.ws;
 
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
 import org.sonar.api.server.ws.WebService;

server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/CheckSecretKeyActionTest.java

 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.server.exceptions.ForbiddenException;

server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/EncryptActionTest.java

 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.server.exceptions.BadRequestException;

server/sonar-webserver-webapi/src/test/java/org/sonar/server/setting/ws/GenerateSecretKeyActionTest.java

 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.server.exceptions.ForbiddenException;

sonar-plugin-api-impl/src/main/java/org/sonar/api/batch/sensor/internal/SensorContextTester.java

 import org.sonar.api.batch.sensor.symbol.NewSymbolTable;
 import org.sonar.api.batch.sensor.symbol.internal.DefaultSymbolTable;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
 import org.sonar.api.config.internal.ConfigurationBridge;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.internal.MetadataLoader;
  */
 public class SensorContextTester implements SensorContext {
 
-  private Settings settings;
+  private MapSettings settings;
   private DefaultFileSystem fs;
   private ActiveRules activeRules;
   private InMemorySensorStorage sensorStorage;
     return new SensorContextTester(moduleBaseDir);
   }
 
-  @Override
-  public Settings settings() {
+  public MapSettings settings() {
     return settings;
   }
 
     return new ConfigurationBridge(settings);
   }
 
-  public SensorContextTester setSettings(Settings settings) {
+  public SensorContextTester setSettings(MapSettings settings) {
     this.settings = settings;
     return this;
   }

sonar-plugin-api/src/main/java/org/sonar/api/config/AesCipher.java → sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/AesCipher.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
 import java.io.File;
 import java.io.IOException;

sonar-plugin-api/src/main/java/org/sonar/api/config/Base64Cipher.java → sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/Base64Cipher.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
 import org.apache.commons.codec.binary.Base64;
 

sonar-plugin-api/src/main/java/org/sonar/api/config/Cipher.java → sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/Cipher.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
 interface Cipher {
   String encrypt(String clearText);

sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/ConfigurationBridge.java

 package org.sonar.api.config.internal;
 
 import java.util.Optional;
-import org.sonar.api.config.Settings;
 import org.sonar.api.config.Configuration;
 
 /**

sonar-plugin-api/src/main/java/org/sonar/api/config/Encryption.java → sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/Encryption.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
 import java.util.HashMap;
 import java.util.Locale;

sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/MapSettings.java

 import java.util.Map;
 import java.util.Optional;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Encryption;
 import org.sonar.api.config.PropertyDefinitions;
-import org.sonar.api.config.Settings;
 
 import static java.util.Collections.unmodifiableMap;
 import static java.util.Objects.requireNonNull;

sonar-plugin-api/src/main/java/org/sonar/api/config/Settings.java → sonar-plugin-api-impl/src/main/java/org/sonar/api/config/internal/Settings.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import org.apache.commons.lang.ArrayUtils;
 import org.apache.commons.lang.StringUtils;
 import org.sonar.api.ce.ComputeEngineSide;
+import org.sonar.api.config.Configuration;
+import org.sonar.api.config.PropertyDefinition;
+import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.api.scanner.ScannerSide;
 import org.sonar.api.server.ServerSide;
 import org.sonar.api.utils.DateUtils;

sonar-plugin-api-impl/src/test/java/org/sonar/api/batch/sensor/internal/SensorContextTesterTest.java

 import org.junit.rules.TemporaryFolder;
 import org.sonar.api.batch.bootstrap.ProjectDefinition;
 import org.sonar.api.batch.fs.InputFile;
+import org.sonar.api.batch.fs.internal.DefaultFileSystem;
+import org.sonar.api.batch.fs.internal.DefaultInputFile;
+import org.sonar.api.batch.fs.internal.DefaultInputModule;
+import org.sonar.api.batch.fs.internal.DefaultTextPointer;
+import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.batch.rule.ActiveRules;
+import org.sonar.api.batch.rule.Severity;
 import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
 import org.sonar.api.batch.rule.internal.NewActiveRule;
-import org.sonar.api.batch.rule.Severity;
 import org.sonar.api.batch.sensor.error.AnalysisError;
 import org.sonar.api.batch.sensor.error.NewAnalysisError;
 import org.sonar.api.batch.sensor.highlighting.TypeOfText;
 import org.sonar.api.batch.sensor.issue.NewExternalIssue;
 import org.sonar.api.batch.sensor.issue.NewIssue;
 import org.sonar.api.batch.sensor.symbol.NewSymbolTable;
-import org.sonar.api.config.Settings;
 import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.batch.fs.internal.DefaultFileSystem;
-import org.sonar.api.batch.fs.internal.DefaultInputFile;
-import org.sonar.api.batch.fs.internal.DefaultInputModule;
-import org.sonar.api.batch.fs.internal.DefaultTextPointer;
-import org.sonar.api.batch.fs.internal.TestInputFileBuilder;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.rules.RuleType;
 
   @Test
   public void testSettings() {
-    Settings settings = new MapSettings();
+    MapSettings settings = new MapSettings();
     settings.setProperty("foo", "bar");
     tester.setSettings(settings);
-    assertThat(tester.settings().getString("foo")).isEqualTo("bar");
+    assertThat(tester.config().get("foo")).contains("bar");
   }
 
   @Test

sonar-plugin-api/src/test/java/org/sonar/api/config/AesCipherTest.java → sonar-plugin-api-impl/src/test/java/org/sonar/api/config/internal/AesCipherTest.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
+import java.io.File;
+import java.net.URL;
+import java.security.InvalidKeyException;
+import java.security.Key;
+import javax.crypto.BadPaddingException;
 import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.lang.StringUtils;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-import javax.crypto.BadPaddingException;
-
-import java.io.File;
-import java.net.URL;
-import java.security.InvalidKeyException;
-import java.security.Key;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
 
     thrown.expect(RuntimeException.class);
     thrown.expectMessage("Invalid AES key");
 
-    URL resource = getClass().getResource("/org/sonar/api/config/AesCipherTest/bad_secret_key.txt");
+    URL resource = getClass().getResource("/org/sonar/api/config/internal/AesCipherTest/bad_secret_key.txt");
     AesCipher cipher = new AesCipher(new File(resource.toURI()).getCanonicalPath());
 
     cipher.encrypt("this is a secret");
   public void decrypt() throws Exception {
     AesCipher cipher = new AesCipher(pathToSecretKey());
 
-    // the following value has been encrypted with the key /org/sonar/api/config/AesCipherTest/aes_secret_key.txt
+    // the following value has been encrypted with the key /org/sonar/api/config/internal/AesCipherTest/aes_secret_key.txt
     String clearText = cipher.decrypt("9mx5Zq4JVyjeChTcVjEide4kWCwusFl7P2dSVXtg9IY=");
 
     assertThat(clearText).isEqualTo("this is a secret");
 
   @Test
   public void decrypt_bad_key() throws Exception {
-    URL resource = getClass().getResource("/org/sonar/api/config/AesCipherTest/bad_secret_key.txt");
+    URL resource = getClass().getResource("/org/sonar/api/config/internal/AesCipherTest/bad_secret_key.txt");
     AesCipher cipher = new AesCipher(new File(resource.toURI()).getCanonicalPath());
 
     try {
 
   @Test
   public void decrypt_other_key() throws Exception {
-    URL resource = getClass().getResource("/org/sonar/api/config/AesCipherTest/other_secret_key.txt");
+    URL resource = getClass().getResource("/org/sonar/api/config/internal/AesCipherTest/other_secret_key.txt");
     AesCipher cipher = new AesCipher(new File(resource.toURI()).getCanonicalPath());
 
     try {
 
   @Test
   public void loadSecretKeyFromFile_trim_content() throws Exception {
-    URL resource = getClass().getResource("/org/sonar/api/config/AesCipherTest/non_trimmed_secret_key.txt");
+    URL resource = getClass().getResource("/org/sonar/api/config/internal/AesCipherTest/non_trimmed_secret_key.txt");
     String path = new File(resource.toURI()).getCanonicalPath();
     AesCipher cipher = new AesCipher(null);
 
   }
 
   private String pathToSecretKey() throws Exception {
-    URL resource = getClass().getResource("/org/sonar/api/config/AesCipherTest/aes_secret_key.txt");
+    URL resource = getClass().getResource("/org/sonar/api/config/internal/AesCipherTest/aes_secret_key.txt");
     return new File(resource.toURI()).getCanonicalPath();
   }
 }

sonar-plugin-api/src/test/java/org/sonar/api/config/EncryptionTest.java → sonar-plugin-api-impl/src/test/java/org/sonar/api/config/internal/EncryptionTest.java

  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
-package org.sonar.api.config;
+package org.sonar.api.config.internal;
 
 import org.junit.Test;
 

sonar-plugin-api-impl/src/test/java/org/sonar/api/config/internal/MapSettingsTest.java

 import org.sonar.api.PropertyType;
 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.config.PropertyDefinitions;
-import org.sonar.api.config.Settings;
 import org.sonar.api.utils.DateUtils;
 
 import static java.util.Collections.singletonList;

sonar-plugin-api/build.gradle

 dependencies {
   // please keep the list grouped by configuration and ordered by name
 
-  compile 'commons-codec:commons-codec'
   compile 'commons-io:commons-io'
   compile 'commons-lang:commons-lang'
   compile 'com.google.code.gson:gson'

sonar-plugin-api/src/main/java/org/sonar/api/batch/bootstrap/ProjectBuilder.java

 package org.sonar.api.batch.bootstrap;
 
 import org.sonar.api.ExtensionPoint;
+import org.sonar.api.config.Configuration;
 import org.sonar.api.scanner.ScannerSide;
 
 /**
 @Deprecated
 public abstract class ProjectBuilder {
 
-  /**
-   * Plugins can use the implementation {@link org.sonar.api.batch.bootstrap.internal.ProjectBuilderContext}
-   * for their unit tests.
-   */
   @Deprecated
   public interface Context {
     ProjectReactor projectReactor();
+
+    /**
+     * Global config (command line arguments, global scanner properties).
+     * @since 8.3 Only as a replacement for injecting Settings
+     */
+    Configuration config();
   }
 
   /**

sonar-plugin-api/src/main/java/org/sonar/api/batch/bootstrap/internal/ProjectBuilderContext.java

 
 import org.sonar.api.batch.bootstrap.ProjectBuilder;
 import org.sonar.api.batch.bootstrap.ProjectReactor;
+import org.sonar.api.config.Configuration;
 
 /**
  * Context that is passed to {@link org.sonar.api.batch.bootstrap.ProjectBuilder} as parameter.
 public class ProjectBuilderContext implements ProjectBuilder.Context {
 
   private final ProjectReactor reactor;
+  private final Configuration configuration;
 
-  public ProjectBuilderContext(ProjectReactor reactor) {
+  public ProjectBuilderContext(ProjectReactor reactor, Configuration configuration) {
     this.reactor = reactor;
+    this.configuration = configuration;
   }
 
   @Override
     return reactor;
   }
 
+  @Override
+  public Configuration config() {
+    return configuration;
+  }
 }

sonar-plugin-api/src/main/java/org/sonar/api/batch/postjob/PostJobContext.java

 import org.sonar.api.batch.AnalysisMode;
 import org.sonar.api.batch.postjob.issue.PostJobIssue;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
 
 /**
  * See {@link PostJob#execute(PostJobContext)}
  */
 public interface PostJobContext {
 
-  /**
-   * @deprecated since 6.5 use {@link #config()}
-   */
-  @Deprecated
-  Settings settings();
-
   /**
    * Get configuration of the current project.
    * @since 6.5

sonar-plugin-api/src/main/java/org/sonar/api/batch/sensor/SensorContext.java

 import org.sonar.api.batch.sensor.rule.NewAdHocRule;
 import org.sonar.api.batch.sensor.symbol.NewSymbolTable;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
 import org.sonar.api.scanner.fs.InputProject;
 import org.sonar.api.scanner.sensor.ProjectSensor;
 import org.sonar.api.utils.Version;
  */
 public interface SensorContext {
 
-  /**
-   * @deprecated since 6.5 use {@link #config()}
-   */
-  @Deprecated
-  Settings settings();
-
   /**
    * Get settings of the project.
    * @since 6.5

sonar-plugin-api/src/test/java/org/sonar/api/batch/bootstrap/ProjectBuilderTest.java

 import java.io.File;
 import org.junit.Test;
 import org.sonar.api.batch.bootstrap.internal.ProjectBuilderContext;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.Configuration;
 import org.sonar.api.config.internal.MapSettings;
 
 import static org.assertj.core.api.Assertions.assertThat;
     // this reactor is created and provided by Sonar
     final ProjectReactor projectReactor = new ProjectReactor(ProjectDefinition.create());
 
-    ProjectBuilder builder = new ProjectBuilderSample(new MapSettings());
-    builder.build(new ProjectBuilderContext(projectReactor));
+    ProjectBuilder builder = new ProjectBuilderSample();
+    final MapSettings settings = new MapSettings();
+    settings.setProperty("foo", "bar");
+    final Configuration configuration = settings.asConfig();
+    builder.build(new ProjectBuilderContext(projectReactor, configuration));
 
     assertThat(projectReactor.getProjects().size(), is(2));
     ProjectDefinition root = projectReactor.getRoot();
   }
 
   final static class ProjectBuilderSample extends ProjectBuilder {
-    private Settings conf;
-
-    public ProjectBuilderSample(Settings conf) {
-      // A real implementation should for example use the settings
-      this.conf = conf;
-    }
 
     @Override
-    protected void build(ProjectReactor reactor) {
+    public void build(Context context) {
+      assertThat(context.config().get("foo")).contains("bar");
       // change name of root project
-      ProjectDefinition root = reactor.getRoot();
+      ProjectDefinition root = context.projectReactor().getRoot();
       root.setName("Name changed by plugin");
 
       // add sub-project

sonar-scanner-engine/src/main/java/org/sonar/scanner/bootstrap/GlobalConfiguration.java

 
 import java.util.Map;
 import javax.annotation.concurrent.Immutable;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.scanner.config.DefaultConfiguration;
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/bootstrap/RawScannerProperties.java

 import java.util.Map;
 import javax.annotation.concurrent.Immutable;
 import org.sonar.api.CoreProperties;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 
 /**
  * Properties that are coming from scanner.

sonar-scanner-engine/src/main/java/org/sonar/scanner/config/DefaultConfiguration.java

 import javax.annotation.concurrent.Immutable;
 import org.apache.commons.lang.ArrayUtils;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.api.utils.log.Logger;

sonar-scanner-engine/src/main/java/org/sonar/scanner/postjob/DefaultPostJobContext.java

 import org.sonar.api.batch.postjob.PostJobContext;
 import org.sonar.api.batch.postjob.issue.PostJobIssue;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
 
 public class DefaultPostJobContext implements PostJobContext {
 
   private final Configuration config;
   private final AnalysisMode analysisMode;
-  private final Settings mutableSettings;
 
-  public DefaultPostJobContext(Configuration config, Settings mutableSettings, AnalysisMode analysisMode) {
+  public DefaultPostJobContext(Configuration config, AnalysisMode analysisMode) {
     this.config = config;
-    this.mutableSettings = mutableSettings;
     this.analysisMode = analysisMode;
   }
 
-  @Override
-  public Settings settings() {
-    return mutableSettings;
-  }
-
   @Override
   public Configuration config() {
     return config;

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ModuleConfiguration.java

 package org.sonar.scanner.scan;
 
 import java.util.Map;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.scanner.config.DefaultConfiguration;
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/MutableModuleSettings.java

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 
 import static java.util.Objects.requireNonNull;
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/MutableProjectSettings.java

 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.scanner.bootstrap.GlobalConfiguration;
 
 import static java.util.Objects.requireNonNull;

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectBuildersExecutor.java

 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 import org.sonar.api.utils.log.Profiler;
+import org.sonar.scanner.bootstrap.GlobalConfiguration;
 
 public class ProjectBuildersExecutor {
 
   private static final Logger LOG = Loggers.get(ProjectBuildersExecutor.class);
 
+  private final GlobalConfiguration globalConfig;
   private final ProjectBuilder[] projectBuilders;
 
-  public ProjectBuildersExecutor(ProjectBuilder... projectBuilders) {
+  public ProjectBuildersExecutor(GlobalConfiguration globalConfig, ProjectBuilder... projectBuilders) {
+    this.globalConfig = globalConfig;
     this.projectBuilders = projectBuilders;
   }
 
-  public ProjectBuildersExecutor() {
-    this(new ProjectBuilder[0]);
+  public ProjectBuildersExecutor(GlobalConfiguration globalConfig) {
+    this(globalConfig, new ProjectBuilder[0]);
   }
 
   public void execute(ProjectReactor reactor) {
     if (projectBuilders.length > 0) {
       Profiler profiler = Profiler.create(LOG).startInfo("Execute project builders");
-      ProjectBuilderContext context = new ProjectBuilderContext(reactor);
+      ProjectBuilderContext context = new ProjectBuilderContext(reactor, globalConfig);
 
       for (ProjectBuilder projectBuilder : projectBuilders) {
         try {

sonar-scanner-engine/src/main/java/org/sonar/scanner/scan/ProjectConfiguration.java

 package org.sonar.scanner.scan;
 
 import java.util.Map;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.scanner.config.DefaultConfiguration;
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/sensor/ModuleSensorContext.java

 import org.sonar.api.SonarRuntime;
 import org.sonar.api.batch.fs.FileSystem;
 import org.sonar.api.batch.fs.InputModule;
+import org.sonar.api.batch.fs.internal.DefaultInputProject;
 import org.sonar.api.batch.rule.ActiveRules;
 import org.sonar.api.batch.sensor.internal.SensorStorage;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
-import org.sonar.api.batch.fs.internal.DefaultInputProject;
 
 @ThreadSafe
 public class ModuleSensorContext extends ProjectSensorContext {
 
   private final InputModule module;
 
-  public ModuleSensorContext(DefaultInputProject project, InputModule module, Configuration config, Settings mutableSettings, FileSystem fs, ActiveRules activeRules,
+  public ModuleSensorContext(DefaultInputProject project, InputModule module, Configuration config, FileSystem fs, ActiveRules activeRules,
     SensorStorage sensorStorage, SonarRuntime sonarRuntime) {
-    super(project, config, mutableSettings, fs, activeRules, sensorStorage, sonarRuntime);
+    super(project, config, fs, activeRules, sensorStorage, sonarRuntime);
     this.module = module;
   }
 

sonar-scanner-engine/src/main/java/org/sonar/scanner/sensor/ProjectSensorContext.java

 import org.sonar.api.batch.sensor.symbol.NewSymbolTable;
 import org.sonar.api.batch.sensor.symbol.internal.DefaultSymbolTable;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Settings;
 import org.sonar.api.scanner.fs.InputProject;
 import org.sonar.api.utils.Version;
 import org.sonar.scanner.sensor.noop.NoOpNewAnalysisError;
 
   static final NoOpNewAnalysisError NO_OP_NEW_ANALYSIS_ERROR = new NoOpNewAnalysisError();
 
-  private final Settings mutableSettings;
   private final FileSystem fs;
   private final ActiveRules activeRules;
   private final SensorStorage sensorStorage;
   private final SonarRuntime sonarRuntime;
   private final Configuration config;
 
-  public ProjectSensorContext(DefaultInputProject project, Configuration config, Settings mutableSettings, FileSystem fs, ActiveRules activeRules,
+  public ProjectSensorContext(DefaultInputProject project, Configuration config, FileSystem fs, ActiveRules activeRules,
     SensorStorage sensorStorage, SonarRuntime sonarRuntime) {
     this.project = project;
     this.config = config;
-    this.mutableSettings = mutableSettings;
     this.fs = fs;
     this.activeRules = activeRules;
     this.sensorStorage = sensorStorage;
     this.sonarRuntime = sonarRuntime;
   }
 
-  @Override
-  public Settings settings() {
-    return mutableSettings;
-  }
-
   @Override
   public Configuration config() {
     return config;

sonar-scanner-engine/src/test/java/org/sonar/scanner/config/DefaultConfigurationTest.java

 import org.junit.Rule;
 import org.junit.Test;
 import org.sonar.api.config.Configuration;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinition;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.api.config.PropertyFieldDefinition;

sonar-scanner-engine/src/test/java/org/sonar/scanner/genericcoverage/GenericCoverageSensorTest.java

 import java.util.Set;
 import org.junit.Rule;
 import org.junit.Test;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.api.utils.log.LogTester;
 import org.sonar.scanner.config.DefaultConfiguration;

sonar-scanner-engine/src/test/java/org/sonar/scanner/genericcoverage/GenericTestExecutionSensorTest.java

 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import org.sonar.api.config.Encryption;
+import org.sonar.api.config.internal.Encryption;
 import org.sonar.api.config.PropertyDefinitions;
 import org.sonar.api.utils.log.LogTester;
 import org.sonar.api.utils.log.LoggerLevel;

sonar-scanner-engine/src/test/java/org/sonar/scanner/platform/DefaultServerTest.java

 import org.junit.Test;
 import org.sonar.api.CoreProperties;
 import org.sonar.api.SonarQubeSide;
-import org.sonar.api.config.Settings;
+import org.sonar.api.config.internal.Settings;
 import org.sonar.api.config.internal.MapSettings;
 import org.sonar.api.internal.SonarRuntimeImpl;
 import org.sonar.api.utils.Version;

sonar-scanner-engine/src/test/java/org/sonar/scanner/postjob/DefaultPostJobContextTest.java

 import org.sonar.api.batch.AnalysisMode;
 import org.sonar.api.config.internal.MapSettings;
 
-import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 public class DefaultPostJobContextTest {
   public void setUp() {
     settings = new MapSettings();
     AnalysisMode analysisMode = mock(AnalysisMode.class);
-    context = new DefaultPostJobContext(settings.asConfig(), settings, analysisMode);
-  }
-
-  @Test
-  public void testSettings() {
-    assertThat(context.settings()).isSameAs(settings);
+    context = new DefaultPostJobContext(settings.asConfig(), analysisMode);
   }
 
   @Test(expected=UnsupportedOperationException.class)

sonar-scanner-engine/src/test/java/org/sonar/scanner/scan/ProjectBuildersExecutorTest.java

 import org.sonar.api.batch.bootstrap.ProjectBuilder.Context;
 import org.sonar.api.batch.bootstrap.ProjectReactor;
 import org.sonar.api.utils.MessageException;
+import org.sonar.scanner.bootstrap.GlobalConfiguration;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doThrow;
 
     exception.expectMessage("Failed to execute project builder: Mock for ProjectBuilder");
     exception.expect(MessageException.class);
-    new ProjectBuildersExecutor(projectBuilders).execute(reactor);
+    new ProjectBuildersExecutor(mock(GlobalConfiguration.class), projectBuilders).execute(reactor);
   }
 
   @Test
 
     exception.expectMessage("Failed to execute project builder: org.sonar.scanner.scan.ProjectBuildersExecutorTest$MyProjectBuilder");
     exception.expect(MessageException.class);
-    new ProjectBuildersExecutor(projectBuilders).execute(reactor);
+    new ProjectBuildersExecutor(mock(GlobalConfiguration.class), projectBuilders).execute(reactor);
   }
 
   static class MyProjectBuilder extends ProjectBuilder {

sonar-scanner-engine/src/test/java/org/sonar/scanner/sensor/ModuleSensorContextTest.java

     settings = new MapSettings();
     sensorStorage = mock(SensorStorage.class);
     runtime = SonarRuntimeImpl.forSonarQube(Version.parse("5.5"), SonarQubeSide.SCANNER, SonarEdition.COMMUNITY);
-    adaptor = new ModuleSensorContext(mock(DefaultInputProject.class), mock(InputModule.class), settings.asConfig(), settings, fs, activeRules, sensorStorage, runtime);
+    adaptor = new ModuleSensorContext(mock(DefaultInputProject.class), mock(InputModule.class), settings.asConfig(), fs, activeRules, sensorStorage, runtime);
   }
 
   @Test
   public void shouldProvideComponents() {
     assertThat(adaptor.activeRules()).isEqualTo(activeRules);
     assertThat(adaptor.fileSystem()).isEqualTo(fs);
-    assertThat(adaptor.settings()).isEqualTo(settings);
     assertThat(adaptor.getSonarQubeVersion()).isEqualTo(Version.parse("5.5"));
     assertThat(adaptor.runtime()).isEqualTo(runtime);