Rename transport version terminology (#133492) (#133514)

This commit further tweaks terminology for the new file-based transport
version system. Specially it renames:
named -> referable
unreferenced -> unreferable
latest -> upper_bound

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/transport/AbstractTransportVersionFuncTest.groovy

@@ -33,27 +33,27 @@ class AbstractTransportVersionFuncTest extends AbstractGradleFuncTest {
         }
     }
 
-    def namedTransportVersion(String name, String ids) {
-        javaResource("myserver", "transport/definitions/named/" + name + ".csv", ids)
+    def referableTransportVersion(String name, String ids) {
+        javaResource("myserver", "transport/definitions/referable/" + name + ".csv", ids)
     }
 
-    def unreferencedTransportVersion(String name, String id) {
-        javaResource("myserver", "transport/definitions/unreferenced/" + name + ".csv", id)
+    def unreferableTransportVersion(String name, String id) {
+        javaResource("myserver", "transport/definitions/unreferable/" + name + ".csv", id)
     }
 
-    def namedAndReferencedTransportVersion(String name, String ids) {
-        return namedAndReferencedTransportVersion(name, ids, "Test${name.capitalize()}")
+    def referableAndReferencedTransportVersion(String name, String ids) {
+        return referableAndReferencedTransportVersion(name, ids, "Test${name.capitalize()}")
     }
 
-    def namedAndReferencedTransportVersion(String name, String ids, String classname) {
+    def referableAndReferencedTransportVersion(String name, String ids, String classname) {
         javaSource("myserver", "org.elasticsearch", classname, "", """
             static final TransportVersion usage = TransportVersion.fromName("${name}");
         """)
-        namedTransportVersion(name, ids)
+        referableTransportVersion(name, ids)
     }
 
-    def latestTransportVersion(String branch, String name, String id) {
-        javaResource("myserver", "transport/latest/" + branch + ".csv","${name},${id}")
+    def transportVersionUpperBound(String branch, String name, String id) {
+        javaResource("myserver", "transport/upper_bounds/" + branch + ".csv","${name},${id}")
     }
 
     def validateReferencesFails(String project) {
@@ -87,11 +87,11 @@ class AbstractTransportVersionFuncTest extends AbstractGradleFuncTest {
             apply plugin: 'elasticsearch.transport-version-references'
             apply plugin: 'elasticsearch.transport-version-resources'
         """
-        namedTransportVersion("existing_91", "8012000")
-        namedTransportVersion("existing_92", "8123000,8012001")
-        unreferencedTransportVersion("initial_9_0_0", "8000000")
-        latestTransportVersion("9.2", "existing_92", "8123000")
-        latestTransportVersion("9.1", "existing_92", "8012001")
+        referableTransportVersion("existing_91", "8012000")
+        referableTransportVersion("existing_92", "8123000,8012001")
+        unreferableTransportVersion("initial_9_0_0", "8000000")
+        transportVersionUpperBound("9.2", "existing_92", "8123000")
+        transportVersionUpperBound("9.1", "existing_92", "8012001")
         // a mock version of TransportVersion, just here so we can compile Dummy.java et al
         javaSource("myserver", "org.elasticsearch", "TransportVersion", "", """
             public static TransportVersion fromName(String name) {

build-tools-internal/src/integTest/groovy/org/elasticsearch/gradle/internal/transport/TransportVersionValidationFuncTest.groovy

@@ -38,22 +38,22 @@ class TransportVersionValidationFuncTest extends AbstractTransportVersionFuncTes
 
     def "references must be defined"() {
         given:
-        namedTransportVersion("not_used", "1000000")
+        referableTransportVersion("not_used", "1000000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/not_used.csv] is not referenced")
+            "[myserver/src/main/resources/transport/definitions/referable/not_used.csv] is not referenced")
     }
 
     def "names must be lowercase alphanum or underscore"() {
         given:
-        namedAndReferencedTransportVersion("${name}", "8100000", "TestNames")
+        referableAndReferencedTransportVersion("${name}", "8100000", "TestNames")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/${name}.csv] does not have a valid name, " +
+            "[myserver/src/main/resources/transport/definitions/referable/${name}.csv] does not have a valid name, " +
             "must be lowercase alphanumeric and underscore")
 
         where:
@@ -62,117 +62,117 @@ class TransportVersionValidationFuncTest extends AbstractTransportVersionFuncTes
 
     def "definitions contain at least one id"() {
         given:
-        namedAndReferencedTransportVersion("empty", "")
+        referableAndReferencedTransportVersion("empty", "")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/empty.csv] does not contain any ids")
+            "[myserver/src/main/resources/transport/definitions/referable/empty.csv] does not contain any ids")
     }
 
     def "definitions have ids in descending order"() {
         given:
-        namedAndReferencedTransportVersion("out_of_order", "8100000,8200000")
+        referableAndReferencedTransportVersion("out_of_order", "8100000,8200000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/out_of_order.csv] does not have ordered ids")
+            "[myserver/src/main/resources/transport/definitions/referable/out_of_order.csv] does not have ordered ids")
     }
 
     def "definition ids are unique"() {
         given:
-        namedAndReferencedTransportVersion("duplicate", "8123000")
+        referableAndReferencedTransportVersion("duplicate", "8123000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] contains id 8123000 already defined in " +
-            "[myserver/src/main/resources/transport/definitions/named/duplicate.csv]")
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] contains id 8123000 already defined in " +
+            "[myserver/src/main/resources/transport/definitions/referable/duplicate.csv]")
     }
 
     def "definitions have bwc ids with non-zero patch part"() {
         given:
-        namedAndReferencedTransportVersion("patched", "8200000,8100000")
+        referableAndReferencedTransportVersion("patched", "8200000,8100000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/patched.csv] contains bwc id [8100000] with a patch part of 0")
+            "[myserver/src/main/resources/transport/definitions/referable/patched.csv] contains bwc id [8100000] with a patch part of 0")
     }
 
     def "definitions have primary ids which cannot change"() {
         given:
-        namedTransportVersion("existing_92", "8500000")
+        referableTransportVersion("existing_92", "8500000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] has modified primary id from 8123000 to 8500000")
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] has modified primary id from 8123000 to 8500000")
     }
 
     def "cannot change committed ids to a branch"() {
         given:
-        namedTransportVersion("existing_92", "8123000,8012002")
+        referableTransportVersion("existing_92", "8123000,8012002")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] modifies existing patch id from 8012001 to 8012002")
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] modifies existing patch id from 8012001 to 8012002")
     }
 
-    def "latest files must reference defined name"() {
+    def "upper bounds files must reference defined name"() {
         given:
-        latestTransportVersion("9.2", "dne", "8123000")
+        transportVersionUpperBound("9.2", "dne", "8123000")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.2.csv] contains transport version name [dne] which is not defined")
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.2.csv] contains transport version name [dne] which is not defined")
     }
 
-    def "latest files id must exist in definition"() {
+    def "upper bound files id must exist in definition"() {
         given:
-        latestTransportVersion("9.2", "existing_92", "8124000")
+        transportVersionUpperBound("9.2", "existing_92", "8124000")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.2.csv] has id 8124000 which is not in definition " +
-            "[myserver/src/main/resources/transport/definitions/named/existing_92.csv]")
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.2.csv] has id 8124000 which is not in definition " +
+            "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv]")
     }
 
-    def "latest files have latest id within base"() {
+    def "upper bound files have latest id within base"() {
         given:
-        latestTransportVersion("9.0", "seemingly_latest", "8110001")
-        namedAndReferencedTransportVersion("original", "8110000")
-        namedAndReferencedTransportVersion("seemingly_latest", "8111000,8110001")
-        namedAndReferencedTransportVersion("actual_latest", "8112000,8110002")
+        transportVersionUpperBound("9.0", "seemingly_latest", "8110001")
+        referableAndReferencedTransportVersion("original", "8110000")
+        referableAndReferencedTransportVersion("seemingly_latest", "8111000,8110001")
+        referableAndReferencedTransportVersion("actual_latest", "8112000,8110002")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.0.csv] has id 8110001 from [seemingly_latest] with base 8110000 " +
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.0.csv] has id 8110001 from [seemingly_latest] with base 8110000 " +
             "but another id 8110002 from [actual_latest] is later for that base")
     }
 
-    def "latest files cannot change base id"() {
+    def "upper bound files cannot change base id"() {
         given:
-        namedAndReferencedTransportVersion("original", "8013000")
-        namedAndReferencedTransportVersion("patch", "8015000,8013001")
-        latestTransportVersion("9.1", "patch", "8013001")
+        referableAndReferencedTransportVersion("original", "8013000")
+        referableAndReferencedTransportVersion("patch", "8015000,8013001")
+        transportVersionUpperBound("9.1", "patch", "8013001")
         when:
         def result = validateResourcesFails()
         then:
-        assertValidateResourcesFailure(result, "Latest transport version file " +
-            "[myserver/src/main/resources/transport/latest/9.1.csv] modifies base id from 8012000 to 8013000")
+        assertValidateResourcesFailure(result, "Transport version upper bound file " +
+            "[myserver/src/main/resources/transport/upper_bounds/9.1.csv] modifies base id from 8012000 to 8013000")
     }
 
     def "ids must be dense"() {
         given:
-        namedAndReferencedTransportVersion("original", "8013000")
-        namedAndReferencedTransportVersion("patch1", "8015000,8013002")
-        latestTransportVersion("9.0", "patch1", "8013002")
+        referableAndReferencedTransportVersion("original", "8013000")
+        referableAndReferencedTransportVersion("patch1", "8015000,8013002")
+        transportVersionUpperBound("9.0", "patch1", "8013002")
         when:
         def result = validateResourcesFails()
         then:
@@ -181,49 +181,49 @@ class TransportVersionValidationFuncTest extends AbstractTransportVersionFuncTes
 
     def "primary id must not be patch version"() {
         given:
-        namedAndReferencedTransportVersion("patch", "8015001")
+        referableAndReferencedTransportVersion("patch", "8015001")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-            "[myserver/src/main/resources/transport/definitions/named/patch.csv] has patch version 8015001 as primary id")
+            "[myserver/src/main/resources/transport/definitions/referable/patch.csv] has patch version 8015001 as primary id")
     }
 
-    def "unreferenced directory is optional"() {
+    def "unreferable directory is optional"() {
         given:
-        file("myserver/src/main/resources/transport/unreferenced/initial_9_0_0.csv").delete()
-        file("myserver/src/main/resources/transport/unreferenced").deleteDir()
+        file("myserver/src/main/resources/transport/unreferable/initial_9_0_0.csv").delete()
+        file("myserver/src/main/resources/transport/unreferable").deleteDir()
         when:
         def result = gradleRunner(":myserver:validateTransportVersionResources").build()
         then:
         result.task(":myserver:validateTransportVersionResources").outcome == TaskOutcome.SUCCESS
     }
 
-    def "latest can refer to an unreferenced definition"() {
+    def "upper bound can refer to an unreferable definition"() {
         given:
-        unreferencedTransportVersion("initial_10.0.0", "10000000")
-        latestTransportVersion("10.0", "initial_10.0.0", "10000000")
+        unreferableTransportVersion("initial_10.0.0", "10000000")
+        transportVersionUpperBound("10.0", "initial_10.0.0", "10000000")
         when:
         def result = gradleRunner(":myserver:validateTransportVersionResources").build()
         then:
         result.task(":myserver:validateTransportVersionResources").outcome == TaskOutcome.SUCCESS
     }
 
-    def "named and unreferenced definitions cannot have the same name"() {
+    def "referable and unreferable definitions cannot have the same name"() {
         given:
-        unreferencedTransportVersion("existing_92", "10000000")
+        unreferableTransportVersion("existing_92", "10000000")
         when:
         def result = validateResourcesFails()
         then:
         assertValidateResourcesFailure(result, "Transport version definition file " +
-                "[myserver/src/main/resources/transport/definitions/named/existing_92.csv] " +
-                "has same name as unreferenced definition " +
-                "[myserver/src/main/resources/transport/definitions/unreferenced/existing_92.csv]")
+                "[myserver/src/main/resources/transport/definitions/referable/existing_92.csv] " +
+                "has same name as unreferable definition " +
+                "[myserver/src/main/resources/transport/definitions/unreferable/existing_92.csv]")
     }
 
-    def "unreferenced definitions can have primary ids that are patches"() {
+    def "unreferable definitions can have primary ids that are patches"() {
         given:
-        unreferencedTransportVersion("initial_10.0.1", "10000001")
+        unreferableTransportVersion("initial_10.0.1", "10000001")
         when:
         def result = gradleRunner(":myserver:validateTransportVersionResources").build()
         then:

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/transport/TransportVersionResourcesService.java

@@ -40,12 +40,12 @@ import javax.inject.Inject;
  *
  * <p>The layout of the transport version resources are as follows:
  * <ul>
- *     <li><b>/transport/definitions/named/</b>
+ *     <li><b>/transport/definitions/referable/</b>
  *     - Definitions that can be looked up by name. The name is the filename before the .csv suffix.</li>
- *     <li><b>/transport/definitions/unreferenced/</b>
+ *     <li><b>/transport/definitions/unreferable/</b>
  *     - Definitions which contain ids that are known at runtime, but cannot be looked up by name.</li>
- *     <li><b>/transport/latest/</b>
- *     - The latest transport version definition for each release branch.</li>
+ *     <li><b>/transport/upper_bounds/</b>
+ *     - The maximum transport version definition that will be loaded for each release branch.</li>
  * </ul>
  */
 public abstract class TransportVersionResourcesService implements BuildService<TransportVersionResourcesService.Parameters> {
@@ -60,9 +60,9 @@ public abstract class TransportVersionResourcesService implements BuildService<T
     public abstract ExecOperations getExecOperations();
 
     private static final Path DEFINITIONS_DIR = Path.of("definitions");
-    private static final Path NAMED_DIR = DEFINITIONS_DIR.resolve("named");
-    private static final Path UNREFERENCED_DIR = DEFINITIONS_DIR.resolve("unreferenced");
-    private static final Path LATEST_DIR = Path.of("latest");
+    private static final Path REFERABLE_DIR = DEFINITIONS_DIR.resolve("referable");
+    private static final Path UNREFERABLE_DIR = DEFINITIONS_DIR.resolve("unreferable");
+    private static final Path UPPER_BOUNDS_DIR = Path.of("upper_bounds");
 
     private final Path transportResourcesDir;
     private final Path rootDir;
@@ -91,79 +91,79 @@ public abstract class TransportVersionResourcesService implements BuildService<T
         return transportResourcesDir.resolve(DEFINITIONS_DIR);
     }
 
-    // return the path, relative to the resources dir, of a named definition
-    private Path getNamedDefinitionRelativePath(String name) {
-        return NAMED_DIR.resolve(name + ".csv");
+    // return the path, relative to the resources dir, of a referable definition
+    private Path getReferableDefinitionRelativePath(String name) {
+        return REFERABLE_DIR.resolve(name + ".csv");
     }
 
-    /** Return all named definitions, mapped by their name. */
-    Map<String, TransportVersionDefinition> getNamedDefinitions() throws IOException {
-        return readDefinitions(transportResourcesDir.resolve(NAMED_DIR));
+    /** Return all referable definitions, mapped by their name. */
+    Map<String, TransportVersionDefinition> getReferableDefinitions() throws IOException {
+        return readDefinitions(transportResourcesDir.resolve(REFERABLE_DIR));
     }
 
-    /** Get a named definition from main if it exists there, or null otherwise */
-    TransportVersionDefinition getNamedDefinitionFromMain(String name) {
-        Path resourcePath = getNamedDefinitionRelativePath(name);
+    /** Get a referable definition from main if it exists there, or null otherwise */
+    TransportVersionDefinition getReferableDefinitionFromMain(String name) {
+        Path resourcePath = getReferableDefinitionRelativePath(name);
         return getMainFile(resourcePath, TransportVersionDefinition::fromString);
     }
 
-    /** Test whether the given named definition exists */
-    boolean namedDefinitionExists(String name) {
-        return Files.exists(transportResourcesDir.resolve(getNamedDefinitionRelativePath(name)));
+    /** Test whether the given referable definition exists */
+    boolean referableDefinitionExists(String name) {
+        return Files.exists(transportResourcesDir.resolve(getReferableDefinitionRelativePath(name)));
     }
 
     /** Return the path within the repository of the given named definition */
-    Path getNamedDefinitionRepositoryPath(TransportVersionDefinition definition) {
-        return rootDir.relativize(transportResourcesDir.resolve(getNamedDefinitionRelativePath(definition.name())));
+    Path getReferableDefinitionRepositoryPath(TransportVersionDefinition definition) {
+        return rootDir.relativize(transportResourcesDir.resolve(getReferableDefinitionRelativePath(definition.name())));
     }
 
-    // return the path, relative to the resources dir, of an unreferenced definition
-    private Path getUnreferencedDefinitionRelativePath(String name) {
-        return UNREFERENCED_DIR.resolve(name + ".csv");
+    // return the path, relative to the resources dir, of an unreferable definition
+    private Path getUnreferableDefinitionRelativePath(String name) {
+        return UNREFERABLE_DIR.resolve(name + ".csv");
     }
 
-    /** Return all unreferenced definitions, mapped by their name. */
-    Map<String, TransportVersionDefinition> getUnreferencedDefinitions() throws IOException {
-        return readDefinitions(transportResourcesDir.resolve(UNREFERENCED_DIR));
+    /** Return all unreferable definitions, mapped by their name. */
+    Map<String, TransportVersionDefinition> getUnreferableDefinitions() throws IOException {
+        return readDefinitions(transportResourcesDir.resolve(UNREFERABLE_DIR));
     }
 
-    /** Get a named definition from main if it exists there, or null otherwise */
-    TransportVersionDefinition getUnreferencedDefinitionFromMain(String name) {
-        Path resourcePath = getUnreferencedDefinitionRelativePath(name);
+    /** Get a referable definition from main if it exists there, or null otherwise */
+    TransportVersionDefinition getUnreferableDefinitionFromMain(String name) {
+        Path resourcePath = getUnreferableDefinitionRelativePath(name);
         return getMainFile(resourcePath, TransportVersionDefinition::fromString);
     }
 
-    /** Return the path within the repository of the given named definition */
-    Path getUnreferencedDefinitionRepositoryPath(TransportVersionDefinition definition) {
-        return rootDir.relativize(transportResourcesDir.resolve(getUnreferencedDefinitionRelativePath(definition.name())));
+    /** Return the path within the repository of the given referable definition */
+    Path getUnreferableDefinitionRepositoryPath(TransportVersionDefinition definition) {
+        return rootDir.relativize(transportResourcesDir.resolve(getUnreferableDefinitionRelativePath(definition.name())));
     }
 
-    /** Read all latest files and return them mapped by their release branch */
-    Map<String, TransportVersionLatest> getLatestByReleaseBranch() throws IOException {
-        Map<String, TransportVersionLatest> latests = new HashMap<>();
-        try (var stream = Files.list(transportResourcesDir.resolve(LATEST_DIR))) {
+    /** Read all upper bound files and return them mapped by their release branch */
+    Map<String, TransportVersionUpperBound> getUpperBounds() throws IOException {
+        Map<String, TransportVersionUpperBound> upperBounds = new HashMap<>();
+        try (var stream = Files.list(transportResourcesDir.resolve(UPPER_BOUNDS_DIR))) {
             for (var latestFile : stream.toList()) {
                 String contents = Files.readString(latestFile, StandardCharsets.UTF_8).strip();
-                var latest = TransportVersionLatest.fromString(latestFile, contents);
-                latests.put(latest.name(), latest);
+                var upperBound = TransportVersionUpperBound.fromString(latestFile, contents);
+                upperBounds.put(upperBound.branch(), upperBound);
             }
         }
-        return latests;
+        return upperBounds;
     }
 
     /** Retrieve the latest transport version for the given release branch on main */
-    TransportVersionLatest getLatestFromMain(String releaseBranch) {
-        Path resourcePath = getLatestRelativePath(releaseBranch);
-        return getMainFile(resourcePath, TransportVersionLatest::fromString);
+    TransportVersionUpperBound getUpperBoundFromMain(String releaseBranch) {
+        Path resourcePath = getUpperBoundRelativePath(releaseBranch);
+        return getMainFile(resourcePath, TransportVersionUpperBound::fromString);
     }
 
     /** Return the path within the repository of the given latest */
-    Path getLatestRepositoryPath(TransportVersionLatest latest) {
-        return rootDir.relativize(transportResourcesDir.resolve(getLatestRelativePath(latest.branch())));
+    Path getUpperBoundRepositoryPath(TransportVersionUpperBound latest) {
+        return rootDir.relativize(transportResourcesDir.resolve(getUpperBoundRelativePath(latest.branch())));
     }
 
-    private Path getLatestRelativePath(String releaseBranch) {
-        return LATEST_DIR.resolve(releaseBranch + ".csv");
+    private Path getUpperBoundRelativePath(String releaseBranch) {
+        return UPPER_BOUNDS_DIR.resolve(releaseBranch + ".csv");
     }
 
     // Return the transport version resources paths that exist in main

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/transport/TransportVersionLatest.java → build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/transport/TransportVersionUpperBound.java

@@ -11,17 +11,22 @@ package org.elasticsearch.gradle.internal.transport;
 
 import java.nio.file.Path;
 
-record TransportVersionLatest(String branch, String name, TransportVersionId id) {
-    public static TransportVersionLatest fromString(Path file, String contents) {
+/**
+ * An object to represent the loaded version of a transport version upper bound.
+ *
+ * An upper bound is the maximum transport version id that should be loaded for a given release branch.
+ */
+record TransportVersionUpperBound(String branch, String name, TransportVersionId id) {
+    public static TransportVersionUpperBound fromString(Path file, String contents) {
         String filename = file.getFileName().toString();
         assert filename.endsWith(".csv");
         String branch = filename.substring(0, filename.length() - 4);
 
         String[] parts = contents.split(",");
         if (parts.length != 2) {
-            throw new IllegalStateException("Invalid transport version latest file [" + file + "]: " + contents);
+            throw new IllegalStateException("Invalid transport version upper bound file [" + file + "]: " + contents);
         }
 
-        return new TransportVersionLatest(branch, parts[0], TransportVersionId.fromString(parts[1]));
+        return new TransportVersionUpperBound(branch, parts[0], TransportVersionId.fromString(parts[1]));
     }
 }

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/transport/ValidateTransportVersionReferencesTask.java

@@ -25,7 +25,7 @@ import java.io.IOException;
 import java.nio.file.Path;
 
 /**
- * Validates that each transport version named reference has a constant definition.
+ * Validates that each transport version reference has a referable definition.
  */
 @CacheableTask
 public abstract class ValidateTransportVersionReferencesTask extends DefaultTask {
@@ -50,7 +50,7 @@ public abstract class ValidateTransportVersionReferencesTask extends DefaultTask
         TransportVersionResourcesService resources = getTransportResources().get();
 
         for (var tvReference : TransportVersionReference.listFromFile(namesFile)) {
-            if (resources.namedDefinitionExists(tvReference.name()) == false) {
+            if (resources.referableDefinitionExists(tvReference.name()) == false) {
                 throw new RuntimeException(
                     "TransportVersion.fromName(\""
                         + tvReference.name()

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/transport/ValidateTransportVersionResourcesTask.java

@@ -62,17 +62,17 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
     public void validateTransportVersions() throws IOException {
         TransportVersionResourcesService resources = getResources().get();
         Set<String> referencedNames = TransportVersionReference.collectNames(getReferencesFiles());
-        Map<String, TransportVersionDefinition> namedDefinitions = resources.getNamedDefinitions();
-        Map<String, TransportVersionDefinition> unreferencedDefinitions = resources.getUnreferencedDefinitions();
-        Map<String, TransportVersionDefinition> allDefinitions = collectAllDefinitions(namedDefinitions, unreferencedDefinitions);
+        Map<String, TransportVersionDefinition> referableDefinitions = resources.getReferableDefinitions();
+        Map<String, TransportVersionDefinition> unreferableDefinitions = resources.getUnreferableDefinitions();
+        Map<String, TransportVersionDefinition> allDefinitions = collectAllDefinitions(referableDefinitions, unreferableDefinitions);
         Map<Integer, List<IdAndDefinition>> idsByBase = collectIdsByBase(allDefinitions.values());
-        Map<String, TransportVersionLatest> latestByReleaseBranch = resources.getLatestByReleaseBranch();
+        Map<String, TransportVersionUpperBound> upperBounds = resources.getUpperBounds();
 
-        for (var definition : namedDefinitions.values()) {
+        for (var definition : referableDefinitions.values()) {
             validateNamedDefinition(definition, referencedNames);
         }
 
-        for (var definition : unreferencedDefinitions.values()) {
+        for (var definition : unreferableDefinitions.values()) {
             validateUnreferencedDefinition(definition);
         }
 
@@ -80,21 +80,21 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
             validateBase(entry.getKey(), entry.getValue());
         }
 
-        for (var latest : latestByReleaseBranch.values()) {
-            validateLatest(latest, allDefinitions, idsByBase);
+        for (var upperBound : upperBounds.values()) {
+            validateUpperBound(upperBound, allDefinitions, idsByBase);
         }
     }
 
     private Map<String, TransportVersionDefinition> collectAllDefinitions(
-        Map<String, TransportVersionDefinition> namedDefinitions,
-        Map<String, TransportVersionDefinition> unreferencedDefinitions
+        Map<String, TransportVersionDefinition> referableDefinitions,
+        Map<String, TransportVersionDefinition> unreferableDefinitions
     ) {
-        Map<String, TransportVersionDefinition> allDefinitions = new HashMap<>(namedDefinitions);
-        for (var entry : unreferencedDefinitions.entrySet()) {
+        Map<String, TransportVersionDefinition> allDefinitions = new HashMap<>(referableDefinitions);
+        for (var entry : unreferableDefinitions.entrySet()) {
             TransportVersionDefinition existing = allDefinitions.put(entry.getKey(), entry.getValue());
             if (existing != null) {
-                Path unreferencedPath = getResources().get().getUnreferencedDefinitionRepositoryPath(entry.getValue());
-                throwDefinitionFailure(existing, "has same name as unreferenced definition [" + unreferencedPath + "]");
+                Path unreferablePath = getResources().get().getUnreferableDefinitionRepositoryPath(entry.getValue());
+                throwDefinitionFailure(existing, "has same name as unreferable definition [" + unreferablePath + "]");
             }
         }
         return allDefinitions;
@@ -123,7 +123,7 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
 
         // validate any modifications
         Map<Integer, TransportVersionId> existingIdsByBase = new HashMap<>();
-        TransportVersionDefinition originalDefinition = getResources().get().getNamedDefinitionFromMain(definition.name());
+        TransportVersionDefinition originalDefinition = getResources().get().getReferableDefinitionFromMain(definition.name());
         if (originalDefinition != null) {
             validateIdenticalPrimaryId(definition, originalDefinition);
             originalDefinition.ids().forEach(id -> existingIdsByBase.put(id.base(), id));
@@ -163,7 +163,7 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
     }
 
     private void validateUnreferencedDefinition(TransportVersionDefinition definition) {
-        TransportVersionDefinition originalDefinition = getResources().get().getUnreferencedDefinitionFromMain(definition.name());
+        TransportVersionDefinition originalDefinition = getResources().get().getUnreferableDefinitionFromMain(definition.name());
         if (originalDefinition != null) {
             validateIdenticalPrimaryId(definition, originalDefinition);
         }
@@ -186,31 +186,31 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
         }
     }
 
-    private void validateLatest(
-        TransportVersionLatest latest,
+    private void validateUpperBound(
+        TransportVersionUpperBound upperBound,
         Map<String, TransportVersionDefinition> definitions,
         Map<Integer, List<IdAndDefinition>> idsByBase
     ) {
-        TransportVersionDefinition latestDefinition = definitions.get(latest.name());
-        if (latestDefinition == null) {
-            throwLatestFailure(latest, "contains transport version name [" + latest.name() + "] which is not defined");
+        TransportVersionDefinition upperBoundDefinition = definitions.get(upperBound.name());
+        if (upperBoundDefinition == null) {
+            throwUpperBoundFailure(upperBound, "contains transport version name [" + upperBound.name() + "] which is not defined");
         }
-        if (latestDefinition.ids().contains(latest.id()) == false) {
-            Path relativePath = getResources().get().getNamedDefinitionRepositoryPath(latestDefinition);
-            throwLatestFailure(latest, "has id " + latest.id() + " which is not in definition [" + relativePath + "]");
+        if (upperBoundDefinition.ids().contains(upperBound.id()) == false) {
+            Path relativePath = getResources().get().getReferableDefinitionRepositoryPath(upperBoundDefinition);
+            throwUpperBoundFailure(upperBound, "has id " + upperBound.id() + " which is not in definition [" + relativePath + "]");
         }
 
-        List<IdAndDefinition> baseIds = idsByBase.get(latest.id().base());
+        List<IdAndDefinition> baseIds = idsByBase.get(upperBound.id().base());
         IdAndDefinition lastId = baseIds.get(baseIds.size() - 1);
-        if (lastId.id().complete() != latest.id().complete()) {
-            throwLatestFailure(
-                latest,
+        if (lastId.id().complete() != upperBound.id().complete()) {
+            throwUpperBoundFailure(
+                upperBound,
                 "has id "
-                    + latest.id()
+                    + upperBound.id()
                     + " from ["
-                    + latest.name()
+                    + upperBound.name()
                     + "] with base "
-                    + latest.id().base()
+                    + upperBound.id().base()
                     + " but another id "
                     + lastId.id().complete()
                     + " from ["
@@ -219,10 +219,13 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
             );
         }
 
-        TransportVersionLatest existingLatest = getResources().get().getLatestFromMain(latest.branch());
-        if (existingLatest != null) {
-            if (latest.id().patch() != 0 && latest.id().base() != existingLatest.id().base()) {
-                throwLatestFailure(latest, "modifies base id from " + existingLatest.id().base() + " to " + latest.id().base());
+        TransportVersionUpperBound existingUpperBound = getResources().get().getUpperBoundFromMain(upperBound.branch());
+        if (existingUpperBound != null) {
+            if (upperBound.id().patch() != 0 && upperBound.id().base() != existingUpperBound.id().base()) {
+                throwUpperBoundFailure(
+                    upperBound,
+                    "modifies base id from " + existingUpperBound.id().base() + " to " + upperBound.id().base()
+                );
             }
         }
     }
@@ -234,7 +237,7 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
             IdAndDefinition current = ids.get(ndx);
 
             if (previous.id().equals(current.id())) {
-                Path existingDefinitionPath = getResources().get().getNamedDefinitionRepositoryPath(previous.definition);
+                Path existingDefinitionPath = getResources().get().getReferableDefinitionRepositoryPath(previous.definition);
                 throwDefinitionFailure(
                     current.definition(),
                     "contains id " + current.id + " already defined in [" + existingDefinitionPath + "]"
@@ -251,12 +254,12 @@ public abstract class ValidateTransportVersionResourcesTask extends DefaultTask
     }
 
     private void throwDefinitionFailure(TransportVersionDefinition definition, String message) {
-        Path relativePath = getResources().get().getNamedDefinitionRepositoryPath(definition);
+        Path relativePath = getResources().get().getReferableDefinitionRepositoryPath(definition);
         throw new IllegalStateException("Transport version definition file [" + relativePath + "] " + message);
     }
 
-    private void throwLatestFailure(TransportVersionLatest latest, String message) {
-        Path relativePath = getResources().get().getLatestRepositoryPath(latest);
-        throw new IllegalStateException("Latest transport version file [" + relativePath + "] " + message);
+    private void throwUpperBoundFailure(TransportVersionUpperBound upperBound, String message) {
+        Path relativePath = getResources().get().getUpperBoundRepositoryPath(upperBound);
+        throw new IllegalStateException("Transport version upper bound file [" + relativePath + "] " + message);
     }
 }

server/src/main/java/org/elasticsearch/TransportVersion.java

@@ -102,8 +102,8 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
 
     /**
      * Constructs a named transport version along with its set of compatible patch versions from x-content.
-     * This method takes in the parameter {@code latest} which is the highest valid transport version id
-     * supported by this node. Versions newer than the current transport version id for this node are discarded.
+     * This method takes in the parameter {@code upperBound} which is the highest transport version id
+     * that will be loaded by this node.
      */
     public static TransportVersion fromBufferedReader(
         String component,
@@ -111,7 +111,7 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
         boolean nameInFile,
         boolean isNamed,
         BufferedReader bufferedReader,
-        Integer latest
+        Integer upperBound
     ) {
         try {
             String line = bufferedReader.readLine();
@@ -149,7 +149,7 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
                 if (idIndex > 0 && ids.get(idIndex - 1) <= ids.get(idIndex)) {
                     throw new IllegalStateException("invalid transport version file format [" + toComponentPath(component, path) + "]");
                 }
-                if (ids.get(idIndex) > latest) {
+                if (ids.get(idIndex) > upperBound) {
                     break;
                 }
                 transportVersion = new TransportVersion(name, ids.get(idIndex), transportVersion);
@@ -162,20 +162,21 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
 
     public static List<TransportVersion> collectFromInputStreams(
         String component,
-        Function<String, InputStream> nameToStream,
-        String latestFileName
+        String resourceRoot,
+        Function<String, InputStream> resourceLoader,
+        String upperBoundFileName
     ) {
-        TransportVersion latest = parseFromBufferedReader(
+        TransportVersion upperBound = parseFromBufferedReader(
             component,
-            "/transport/latest/" + latestFileName,
-            nameToStream,
+            resourceRoot + "/upper_bounds/" + upperBoundFileName,
+            resourceLoader,
             (c, p, br) -> fromBufferedReader(c, p, true, false, br, Integer.MAX_VALUE)
         );
-        if (latest != null) {
+        if (upperBound != null) {
             List<String> versionRelativePaths = parseFromBufferedReader(
                 component,
-                "/transport/definitions/manifest.txt",
-                nameToStream,
+                resourceRoot + "/definitions/manifest.txt",
+                resourceLoader,
                 (c, p, br) -> br.lines().filter(line -> line.isBlank() == false).toList()
             );
             if (versionRelativePaths != null) {
@@ -183,9 +184,9 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
                 for (String versionRelativePath : versionRelativePaths) {
                     TransportVersion transportVersion = parseFromBufferedReader(
                         component,
-                        "/transport/definitions/" + versionRelativePath,
-                        nameToStream,
-                        (c, p, br) -> fromBufferedReader(c, p, false, versionRelativePath.startsWith("named/"), br, latest.id())
+                        resourceRoot + "/definitions/" + versionRelativePath,
+                        resourceLoader,
+                        (c, p, br) -> fromBufferedReader(c, p, false, versionRelativePath.startsWith("referable/"), br, upperBound.id())
                     );
                     if (transportVersion != null) {
                         transportVersions.add(transportVersion);
@@ -218,7 +219,7 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
      * Finds a {@link TransportVersion} by its name. The parameter {@code name} must be a {@link String}
      * direct value or validation checks will fail. {@code TransportVersion.fromName("direct_value")}.
      * <p>
-     * This will only return the latest known named transport version for a given name and not its
+     * This will only return the latest known referable transport version for a given name and not its
      * patch versions. Patch versions are constructed as a linked list internally and may be found by
      * cycling through them in a loop using {@link TransportVersion#nextPatchVersion()}.
      *
@@ -331,7 +332,7 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
      * and all of its patch ids for compatibility. This replaces the pattern
      * of {@code wireTV.onOrAfter(TV_FEATURE) || wireTV.isPatchFrom(TV_FEATURE_BACKPORT) || ...}
      * for unnamed transport versions with {@code wireTV.supports(TV_FEATURE)} for named
-     * transport versions (since named versions know about their own patch versions).
+     * transport versions (since referable versions know about their own patch versions).
      * <p>
      * The recommended use of this method is to declare a static final {@link TransportVersion}
      * as part of the file that it's used in. This constant is then used in conjunction with
@@ -402,10 +403,10 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
     }
 
     /**
-     * This class holds various data structures for looking up known transport versions both
-     * named and unnamed. While we transition to named transport versions, this class will
+     * This class holds various data structures for loading transport versions, both
+     * named file-based definitions and unnamed. While we transition to file-based transport versions, this class will
      * load and merge unnamed transport versions from {@link TransportVersions} along with
-     * named transport versions specified in a manifest file in resources.
+     * transport version definitions specified in a manifest file in resources.
      */
     private static class VersionsHolder {
 
@@ -420,6 +421,7 @@ public record TransportVersion(String name, int id, TransportVersion nextPatchVe
             List<TransportVersion> allVersions = new ArrayList<>(TransportVersions.DEFINED_VERSIONS);
             List<TransportVersion> streamVersions = collectFromInputStreams(
                 "<server>",
+                "/transport",
                 TransportVersion.class::getResourceAsStream,
                 Version.CURRENT.major + "." + Version.CURRENT.minor + ".csv"
             );