Move license settings (#94566)

Continued refactoring of the license service. This commit follows #94261
which moved the LicenseService -> ClusterStateLicenseService and re-introduced
LicenseService as interface. That change did not move the settings to keep the diff small.

This change moves those settings to a new class LicenseSettings.
LicenseService will be re-introduced a subsequent commit.

Author: jakelandis

x-pack/plugin/autoscaling/src/internalClusterTest/java/org/elasticsearch/xpack/autoscaling/AbstractFrozenAutoscalingIntegTestCase.java

@@ -39,7 +39,7 @@
 import java.util.stream.IntStream;
 
 import static org.elasticsearch.index.IndexSettings.INDEX_SOFT_DELETES_SETTING;
-import static org.elasticsearch.license.LicenseService.SELF_GENERATED_LICENSE_TYPE;
+import static org.elasticsearch.license.LicenseSettings.SELF_GENERATED_LICENSE_TYPE;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 

x-pack/plugin/ccr/src/test/java/org/elasticsearch/xpack/CcrIntegTestCase.java

@@ -57,7 +57,7 @@
 import org.elasticsearch.index.shard.ShardId;
 import org.elasticsearch.indices.IndicesService;
 import org.elasticsearch.indices.store.IndicesStore;
-import org.elasticsearch.license.LicenseService;
+import org.elasticsearch.license.LicenseSettings;
 import org.elasticsearch.license.LicensesMetadata;
 import org.elasticsearch.persistent.PersistentTasksCustomMetadata;
 import org.elasticsearch.plugins.Plugin;
@@ -304,7 +304,7 @@ private NodeConfigurationSource createNodeConfigurationSource(final String leade
         builder.put(XPackSettings.SECURITY_ENABLED.getKey(), false);
         builder.put(XPackSettings.WATCHER_ENABLED.getKey(), false);
         builder.put(XPackSettings.MACHINE_LEARNING_ENABLED.getKey(), false);
-        builder.put(LicenseService.SELF_GENERATED_LICENSE_TYPE.getKey(), "trial");
+        builder.put(LicenseSettings.SELF_GENERATED_LICENSE_TYPE.getKey(), "trial");
         // Let cluster state api return quickly in order to speed up auto follow tests:
         builder.put(CcrSettings.CCR_WAIT_FOR_METADATA_TIMEOUT.getKey(), TimeValue.timeValueMillis(100));
         if (leaderCluster) {

x-pack/plugin/ccr/src/test/java/org/elasticsearch/xpack/CcrSingleNodeTestCase.java

@@ -14,7 +14,7 @@
 import org.elasticsearch.cluster.service.ClusterService;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.core.TimeValue;
-import org.elasticsearch.license.LicenseService;
+import org.elasticsearch.license.LicenseSettings;
 import org.elasticsearch.license.LicensesMetadata;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.ESSingleNodeTestCase;
@@ -48,7 +48,7 @@ protected Settings nodeSettings() {
         builder.put(XPackSettings.SECURITY_ENABLED.getKey(), false);
         builder.put(XPackSettings.WATCHER_ENABLED.getKey(), false);
         builder.put(XPackSettings.MACHINE_LEARNING_ENABLED.getKey(), false);
-        builder.put(LicenseService.SELF_GENERATED_LICENSE_TYPE.getKey(), "trial");
+        builder.put(LicenseSettings.SELF_GENERATED_LICENSE_TYPE.getKey(), "trial");
         // Let cluster state api return quickly in order to speed up auto follow tests:
         builder.put(CcrSettings.CCR_WAIT_FOR_METADATA_TIMEOUT.getKey(), TimeValue.timeValueMillis(100));
         return builder.build();

x-pack/plugin/core/src/javaRestTest/java/org/elasticsearch/xpack/core/LicenseInstallationIT.java

@@ -16,7 +16,7 @@
 import org.elasticsearch.common.util.concurrent.ThreadContext;
 import org.elasticsearch.core.TimeValue;
 import org.elasticsearch.license.License;
-import org.elasticsearch.license.LicenseService;
+import org.elasticsearch.license.LicenseSettings;
 import org.elasticsearch.license.TestUtils;
 import org.elasticsearch.test.rest.ESRestTestCase;
 import org.elasticsearch.xcontent.ToXContent;
@@ -131,8 +131,8 @@ private Request createPutLicenseRequest(License signedLicense) throws IOExceptio
     private License generateRandomLicense(String licenseId, long expiryDate) throws Exception {
         int version = randomIntBetween(VERSION_NO_FEATURE_TYPE, VERSION_CURRENT);
         License.LicenseType type = version < VERSION_ENTERPRISE
-            ? randomValueOtherThan(License.LicenseType.ENTERPRISE, () -> randomFrom(LicenseService.ALLOWABLE_UPLOAD_TYPES))
-            : randomFrom(LicenseService.ALLOWABLE_UPLOAD_TYPES);
+            ? randomValueOtherThan(License.LicenseType.ENTERPRISE, () -> randomFrom(LicenseSettings.ALLOWABLE_UPLOAD_TYPES))
+            : randomFrom(LicenseSettings.ALLOWABLE_UPLOAD_TYPES);
         final License.Builder builder = License.builder()
             .uid(licenseId)
             .version(version)

x-pack/plugin/core/src/main/java/org/elasticsearch/license/ClusterStateLicenseService.java

@@ -79,7 +79,7 @@ public class ClusterStateLicenseService extends AbstractLifecycleComponent imple
 
     /**
      * Which license types are permitted to be uploaded to the cluster
-     * @see LicenseService#ALLOWED_LICENSE_TYPES_SETTING
+     * @see LicenseSettings#ALLOWED_LICENSE_TYPES_SETTING
      */
     private final List<License.LicenseType> allowedLicenseTypes;
 
@@ -115,7 +115,7 @@ public ClusterStateLicenseService(
         this.clock = clock;
         this.scheduler = new SchedulerEngine(settings, clock);
         this.licenseState = licenseState;
-        this.allowedLicenseTypes = LicenseService.ALLOWED_LICENSE_TYPES_SETTING.get(settings);
+        this.allowedLicenseTypes = LicenseSettings.ALLOWED_LICENSE_TYPES_SETTING.get(settings);
         this.scheduler.register(this);
         populateExpirationCallbacks();
 
@@ -317,12 +317,12 @@ private LicensesMetadata getLicensesMetadata() {
 
     void startTrialLicense(PostStartTrialRequest request, final ActionListener<PostStartTrialResponse> listener) {
         License.LicenseType requestedType = License.LicenseType.parse(request.getType());
-        if (LicenseService.VALID_TRIAL_TYPES.contains(requestedType) == false) {
+        if (LicenseSettings.VALID_TRIAL_TYPES.contains(requestedType) == false) {
             throw new IllegalArgumentException(
                 "Cannot start trial of type ["
                     + requestedType.getTypeName()
                     + "]. Valid trial types are ["
-                    + LicenseService.VALID_TRIAL_TYPES.stream()
+                    + LicenseSettings.VALID_TRIAL_TYPES.stream()
                         .map(License.LicenseType::getTypeName)
                         .sorted()
                         .collect(Collectors.joining(","))
@@ -455,7 +455,7 @@ public void clusterChanged(ClusterChangedEvent event) {
 
     protected String getExpiryWarning(long licenseExpiryDate, long currentTime) {
         final long diff = licenseExpiryDate - currentTime;
-        if (LicenseService.LICENSE_EXPIRATION_WARNING_PERIOD.getMillis() > diff) {
+        if (LicenseSettings.LICENSE_EXPIRATION_WARNING_PERIOD.getMillis() > diff) {
             final long days = TimeUnit.MILLISECONDS.toDays(diff);
             final String expiryMessage = (days == 0 && diff > 0)
                 ? "expires today"
@@ -483,7 +483,7 @@ protected void updateLicenseState(final License license) {
         }
         if (license != null) {
             final boolean active;
-            if (LicenseUtils.getExpiryDate(license) == LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS) {
+            if (LicenseUtils.getExpiryDate(license) == LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS) {
                 active = true;
             } else {
                 active = time >= license.issueDate() && time < LicenseUtils.getExpiryDate(license);
@@ -544,7 +544,7 @@ SchedulerEngine.Schedule nextLicenseCheck(License license) {
             } else if (time < LicenseUtils.getExpiryDate(license)) {
                 // Re-check the license every day during the warning period up to the license expiration.
                 // This will cause the warning message to be updated that is emitted on soon-expiring license use.
-                long nextTime = LicenseUtils.getExpiryDate(license) - LicenseService.LICENSE_EXPIRATION_WARNING_PERIOD.getMillis();
+                long nextTime = LicenseUtils.getExpiryDate(license) - LicenseSettings.LICENSE_EXPIRATION_WARNING_PERIOD.getMillis();
                 while (nextTime <= time) {
                     nextTime += TimeValue.timeValueDays(1).getMillis();
                 }

x-pack/plugin/core/src/main/java/org/elasticsearch/license/License.java

@@ -264,7 +264,7 @@ private License(
         // We will validate that only a basic license can have the BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS
         // in the validate() method.
         if (expiryDate == -1) {
-            this.expiryDate = LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS;
+            this.expiryDate = LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS;
         } else {
             this.expiryDate = expiryDate;
         }
@@ -381,7 +381,7 @@ private void validate() {
             throw new IllegalStateException("feature can not be null");
         } else if (expiryDate == -1) {
             throw new IllegalStateException("expiryDate has to be set");
-        } else if (expiryDate == LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS && LicenseType.isBasic(type) == false) {
+        } else if (expiryDate == LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS && LicenseType.isBasic(type) == false) {
             throw new IllegalStateException("only basic licenses are allowed to have no expiration");
         }
 
@@ -527,7 +527,7 @@ public XContentBuilder toInnerXContent(XContentBuilder builder, Params params) t
             builder.field(Fields.FEATURE, feature);
         }
 
-        if (expiryDate != LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS) {
+        if (expiryDate != LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS) {
             builder.timeField(Fields.EXPIRY_DATE_IN_MILLIS, Fields.EXPIRY_DATE, expiryDate);
         }
 

x-pack/plugin/core/src/main/java/org/elasticsearch/license/LicenseService.java renamed to x-pack/plugin/core/src/main/java/org/elasticsearch/license/LicenseSettings.java

@@ -16,8 +16,11 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public interface LicenseService {
-    Setting<License.LicenseType> SELF_GENERATED_LICENSE_TYPE = new Setting<>(
+/**
+ * Settings related to the license.
+ */
+public abstract class LicenseSettings {
+    public static final Setting<License.LicenseType> SELF_GENERATED_LICENSE_TYPE = new Setting<>(
         "xpack.license.self_generated.type",
         License.LicenseType.BASIC.getTypeName(),
         (s) -> {
@@ -26,17 +29,17 @@ public interface LicenseService {
         },
         Setting.Property.NodeScope
     );
-    List<License.LicenseType> ALLOWABLE_UPLOAD_TYPES = getAllowableUploadTypes();
-    Setting<List<License.LicenseType>> ALLOWED_LICENSE_TYPES_SETTING = Setting.listSetting(
+    public static final List<License.LicenseType> ALLOWABLE_UPLOAD_TYPES = getAllowableUploadTypes();
+    public static final Setting<List<License.LicenseType>> ALLOWED_LICENSE_TYPES_SETTING = Setting.listSetting(
         "xpack.license.upload.types",
         ALLOWABLE_UPLOAD_TYPES.stream().map(License.LicenseType::getTypeName).toList(),
         License.LicenseType::parse,
-        LicenseService::validateUploadTypesSetting,
+        LicenseSettings::validateUploadTypesSetting,
         Setting.Property.NodeScope
     );
     // pkg private for tests
-    TimeValue NON_BASIC_SELF_GENERATED_LICENSE_DURATION = TimeValue.timeValueHours(30 * 24);
-    Set<License.LicenseType> VALID_TRIAL_TYPES = Set.of(
+    static final TimeValue NON_BASIC_SELF_GENERATED_LICENSE_DURATION = TimeValue.timeValueHours(30 * 24);
+    static final Set<License.LicenseType> VALID_TRIAL_TYPES = Set.of(
         License.LicenseType.GOLD,
         License.LicenseType.PLATINUM,
         License.LicenseType.ENTERPRISE,
@@ -45,19 +48,19 @@ public interface LicenseService {
     /**
      * Period before the license expires when warning starts being added to the response header
      */
-    TimeValue LICENSE_EXPIRATION_WARNING_PERIOD = TimeValue.timeValueDays(7);
-    long BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS = XPackInfoResponse.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS;
+    static final TimeValue LICENSE_EXPIRATION_WARNING_PERIOD = TimeValue.timeValueDays(7);
+    static final long BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS = XPackInfoResponse.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS;
     /**
      * Max number of nodes licensed by generated trial license
      */
-    int SELF_GENERATED_LICENSE_MAX_NODES = 1000;
-    int SELF_GENERATED_LICENSE_MAX_RESOURCE_UNITS = SELF_GENERATED_LICENSE_MAX_NODES;
+    static final int SELF_GENERATED_LICENSE_MAX_NODES = 1000;
+    static final int SELF_GENERATED_LICENSE_MAX_RESOURCE_UNITS = SELF_GENERATED_LICENSE_MAX_NODES;
 
-    static List<License.LicenseType> getAllowableUploadTypes() {
+    private static List<License.LicenseType> getAllowableUploadTypes() {
         return Stream.of(License.LicenseType.values()).filter(t -> t != License.LicenseType.BASIC).toList();
     }
 
-    static void validateUploadTypesSetting(List<License.LicenseType> value) {
+    private static void validateUploadTypesSetting(List<License.LicenseType> value) {
         if (ALLOWABLE_UPLOAD_TYPES.containsAll(value) == false) {
             throw new IllegalArgumentException(
                 "Invalid value ["

x-pack/plugin/core/src/main/java/org/elasticsearch/license/LicenseUtils.java

@@ -49,7 +49,7 @@ public static boolean isLicenseExpiredException(ElasticsearchSecurityException e
 
     public static boolean licenseNeedsExtended(License license) {
         return LicenseType.isBasic(license.type())
-            && getExpiryDate(license) != LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS;
+            && getExpiryDate(license) != LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS;
     }
 
     /**

x-pack/plugin/core/src/main/java/org/elasticsearch/license/StartBasicClusterTask.java

@@ -100,18 +100,18 @@ public void onFailure(@Nullable Exception e) {
     private boolean shouldGenerateNewBasicLicense(License currentLicense) {
         return currentLicense == null
             || License.LicenseType.isBasic(currentLicense.type()) == false
-            || LicenseService.SELF_GENERATED_LICENSE_MAX_NODES != currentLicense.maxNodes()
-            || LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS != LicenseUtils.getExpiryDate(currentLicense);
+            || LicenseSettings.SELF_GENERATED_LICENSE_MAX_NODES != currentLicense.maxNodes()
+            || LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS != LicenseUtils.getExpiryDate(currentLicense);
     }
 
     private License generateBasicLicense(DiscoveryNodes discoveryNodes) {
         final License.Builder specBuilder = License.builder()
             .uid(UUID.randomUUID().toString())
             .issuedTo(clusterName)
-            .maxNodes(LicenseService.SELF_GENERATED_LICENSE_MAX_NODES)
+            .maxNodes(LicenseSettings.SELF_GENERATED_LICENSE_MAX_NODES)
             .issueDate(clock.millis())
             .type(License.LicenseType.BASIC)
-            .expiryDate(LicenseService.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS);
+            .expiryDate(LicenseSettings.BASIC_SELF_GENERATED_LICENSE_EXPIRATION_MILLIS);
 
         return SelfGeneratedLicense.create(specBuilder, discoveryNodes);
     }

x-pack/plugin/core/src/main/java/org/elasticsearch/license/StartTrialClusterTask.java

@@ -75,7 +75,7 @@ private LicensesMetadata execute(
             return currentLicensesMetadata;
         } else if (currentLicensesMetadata == null || currentLicensesMetadata.isEligibleForTrial()) {
             long issueDate = clock.millis();
-            long expiryDate = issueDate + LicenseService.NON_BASIC_SELF_GENERATED_LICENSE_DURATION.getMillis();
+            long expiryDate = issueDate + LicenseSettings.NON_BASIC_SELF_GENERATED_LICENSE_DURATION.getMillis();
 
             License.Builder specBuilder = License.builder()
                 .uid(UUID.randomUUID().toString())
@@ -84,9 +84,9 @@ private LicensesMetadata execute(
                 .type(request.getType())
                 .expiryDate(expiryDate);
             if (License.LicenseType.isEnterprise(request.getType())) {
-                specBuilder.maxResourceUnits(LicenseService.SELF_GENERATED_LICENSE_MAX_RESOURCE_UNITS);
+                specBuilder.maxResourceUnits(LicenseSettings.SELF_GENERATED_LICENSE_MAX_RESOURCE_UNITS);
             } else {
-                specBuilder.maxNodes(LicenseService.SELF_GENERATED_LICENSE_MAX_NODES);
+                specBuilder.maxNodes(LicenseSettings.SELF_GENERATED_LICENSE_MAX_NODES);
             }
             License selfGeneratedLicense = SelfGeneratedLicense.create(specBuilder, discoveryNodes);
             LicensesMetadata newLicensesMetadata = new LicensesMetadata(selfGeneratedLicense, Version.CURRENT);