Distinguish between implicit (zone-scoped) and declared endpoints

10 files changed, 107 insertions, 91 deletions

diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/RoutingController.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/RoutingController.java
index 5d02302795d..6afee557029 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/RoutingController.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/RoutingController.java
@@ -86,8 +86,8 @@ public class RoutingController {
         return rotationRepository;
     }
 
-    /** Returns endpoints for given deployment */
-    public EndpointList endpointsOf(DeploymentId deployment) {
+    /** Read and return zone-scoped endpoints for given deployment */
+    public EndpointList readEndpointsOf(DeploymentId deployment) {
         Set<Endpoint> endpoints = new LinkedHashSet<>();
         boolean isSystemApplication = SystemApplication.matching(deployment.applicationId()).isPresent();
         // Avoid reading application more than once per call to this
@@ -104,53 +104,52 @@ public class RoutingController {
         return EndpointList.copyOf(endpoints);
     }
 
-    /** Returns global-scoped endpoints for given instance */
-    public EndpointList endpointsOf(ApplicationId instance) {
+    /** Read application and return declared endpoints for given instance */
+    public EndpointList readDeclaredEndpointsOf(ApplicationId instance) {
         if (SystemApplication.matching(instance).isPresent()) return EndpointList.EMPTY;
-        return endpointsOf(controller.applications().requireApplication(TenantAndApplicationId.from(instance)),
-                                                                        instance.instance());
+        return readDeclaredEndpointsOf(TenantAndApplicationId.from(instance)).instance(instance.instance());
     }
 
-    /** Returns global-scoped endpoints for given instance */
-    public EndpointList endpointsOf(Application application, InstanceName instanceName) {
-        Set<Endpoint> endpoints = new LinkedHashSet<>();
-        Instance instance = application.require(instanceName);
-        DeploymentSpec deploymentSpec = application.deploymentSpec();
-        Optional<DeploymentInstanceSpec> spec = deploymentSpec.instance(instanceName);
-        if (spec.isEmpty()) return EndpointList.EMPTY;
-        // Add endpoint declared with legacy syntax
-        spec.get().globalServiceId().ifPresent(clusterId -> {
-            List<DeploymentId> deployments = spec.get().zones().stream()
-                                                 .filter(zone -> zone.concerns(Environment.prod))
-                                                 .map(zone -> new DeploymentId(instance.id(), ZoneId.from(Environment.prod, zone.region().get())))
-                                                 .collect(Collectors.toList());
-            RoutingId routingId = RoutingId.of(instance.id(), EndpointId.defaultId());
-            endpoints.addAll(computeGlobalEndpoints(routingId, ClusterSpec.Id.from(clusterId), deployments, deploymentSpec));
-        });
-        // Add endpoints declared with current syntax
-        spec.get().endpoints().forEach(declaredEndpoint -> {
-            RoutingId routingId = RoutingId.of(instance.id(), EndpointId.of(declaredEndpoint.endpointId()));
-            List<DeploymentId> deployments = declaredEndpoint.regions().stream()
-                                                             .map(region -> new DeploymentId(instance.id(),
-                                                                                             ZoneId.from(Environment.prod, region)))
-                                                             .collect(Collectors.toList());
-            endpoints.addAll(computeGlobalEndpoints(routingId, ClusterSpec.Id.from(declaredEndpoint.containerId()), deployments, deploymentSpec));
-        });
-        return EndpointList.copyOf(endpoints);
+    /** Read application and return declared endpoints for given application */
+    public EndpointList readDeclaredEndpointsOf(TenantAndApplicationId application) {
+        return declaredEndpointsOf(controller.applications().requireApplication(application));
     }
 
-    /** Returns application-scoped endpoints for given application */
-    public EndpointList endpointsOf(TenantAndApplicationId applicationId) {
-        Application app = controller.applications().requireApplication(applicationId);
+    /** Returns endpoints declared in {@link DeploymentSpec} for given application */
+    public EndpointList declaredEndpointsOf(Application application) {
         Set<Endpoint> endpoints = new LinkedHashSet<>();
-        for (var declaredEndpoint : app.deploymentSpec().endpoints()) {
+        for (var instance : application.instances().values()) {
+            DeploymentSpec deploymentSpec = application.deploymentSpec();
+            Optional<DeploymentInstanceSpec> spec = application.deploymentSpec().instance(instance.name());
+            if (spec.isEmpty()) return EndpointList.EMPTY;
+            // Add endpoint declared with legacy syntax
+            spec.get().globalServiceId().ifPresent(clusterId -> {
+                List<DeploymentId> deployments = spec.get().zones().stream()
+                                                     .filter(zone -> zone.concerns(Environment.prod))
+                                                     .map(zone -> new DeploymentId(instance.id(), ZoneId.from(Environment.prod, zone.region().get())))
+                                                     .collect(Collectors.toList());
+                RoutingId routingId = RoutingId.of(instance.id(), EndpointId.defaultId());
+                endpoints.addAll(computeGlobalEndpoints(routingId, ClusterSpec.Id.from(clusterId), deployments, deploymentSpec));
+            });
+            // Add endpoints declared with current syntax
+            spec.get().endpoints().forEach(declaredEndpoint -> {
+                RoutingId routingId = RoutingId.of(instance.id(), EndpointId.of(declaredEndpoint.endpointId()));
+                List<DeploymentId> deployments = declaredEndpoint.regions().stream()
+                                                                 .map(region -> new DeploymentId(instance.id(),
+                                                                                                 ZoneId.from(Environment.prod, region)))
+                                                                 .collect(Collectors.toList());
+                endpoints.addAll(computeGlobalEndpoints(routingId, ClusterSpec.Id.from(declaredEndpoint.containerId()), deployments, deploymentSpec));
+            });
+        }
+        // Add application endpoints
+        for (var declaredEndpoint : application.deploymentSpec().endpoints()) {
             Map<DeploymentId, Integer> deployments = declaredEndpoint.targets().stream()
-                                                                     .collect(Collectors.toMap(t -> new DeploymentId(applicationId.instance(t.instance()),
+                                                                     .collect(Collectors.toMap(t -> new DeploymentId(application.id().instance(t.instance()),
                                                                                                                      ZoneId.from(Environment.prod, t.region())),
                                                                                                t -> t.weight()));
-            List<RoutingMethod> availableRoutingMethods = routingMethodsOfAll(deployments.keySet(), app.deploymentSpec());
+            List<RoutingMethod> availableRoutingMethods = routingMethodsOfAll(deployments.keySet(), application.deploymentSpec());
             for (var routingMethod : availableRoutingMethods) {
-                endpoints.add(Endpoint.of(applicationId)
+                endpoints.add(Endpoint.of(application.id())
                                       .targetApplication(EndpointId.of(declaredEndpoint.endpointId()),
                                                          ClusterSpec.Id.from(declaredEndpoint.containerId()),
                                                          deployments)
@@ -162,11 +161,11 @@ public class RoutingController {
         return EndpointList.copyOf(endpoints);
     }
 
-    /** Returns all zone-scoped endpoints and corresponding cluster IDs for given deployments, grouped by their zone */
-    public Map<ZoneId, List<Endpoint>> zoneEndpointsOf(Collection<DeploymentId> deployments) {
+    /** Read and return zone-scoped endpoints for given deployments, grouped by their zone */
+    public Map<ZoneId, List<Endpoint>> readZoneEndpointsOf(Collection<DeploymentId> deployments) {
         var endpoints = new TreeMap<ZoneId, List<Endpoint>>(Comparator.comparing(ZoneId::value));
         for (var deployment : deployments) {
-            EndpointList zoneEndpoints = endpointsOf(deployment).scope(Endpoint.Scope.zone).not().legacy();
+            EndpointList zoneEndpoints = readEndpointsOf(deployment).scope(Endpoint.Scope.zone).not().legacy();
             zoneEndpoints = directEndpoints(zoneEndpoints, deployment.applicationId());
             if  ( ! zoneEndpoints.isEmpty()) {
                 endpoints.put(deployment.zoneId(), zoneEndpoints.asList());
@@ -206,7 +205,7 @@ public class RoutingController {
 
     /** Change status of all global endpoints for given deployment */
     public void setGlobalRotationStatus(DeploymentId deployment, EndpointStatus status) {
-        endpointsOf(deployment.applicationId()).requiresRotation().primary().ifPresent(endpoint -> {
+        readDeclaredEndpointsOf(deployment.applicationId()).requiresRotation().primary().ifPresent(endpoint -> {
             try {
                 controller.serviceRegistry().configServer().setGlobalRotationStatus(deployment, endpoint.upstreamIdOf(deployment), status);
             } catch (Exception e) {
@@ -218,7 +217,7 @@ public class RoutingController {
     /** Get global endpoint status for given deployment */
     public Map<Endpoint, EndpointStatus> globalRotationStatus(DeploymentId deployment) {
         var routingEndpoints = new LinkedHashMap<Endpoint, EndpointStatus>();
-        endpointsOf(deployment.applicationId()).requiresRotation().primary().ifPresent(endpoint -> {
+        readDeclaredEndpointsOf(deployment.applicationId()).requiresRotation().primary().ifPresent(endpoint -> {
             var upstreamName = endpoint.upstreamIdOf(deployment);
             var status = controller.serviceRegistry().configServer().getGlobalRotationStatus(deployment, upstreamName);
             routingEndpoints.put(endpoint, status);
@@ -241,17 +240,18 @@ public class RoutingController {
         return application;
     }
 
-    /** Returns the global endpoints for given deployment as container endpoints */
+    /** Returns the global and application-level endpoints for given deployment, as container endpoints */
     public Set<ContainerEndpoint> containerEndpointsOf(Application application, InstanceName instanceName, ZoneId zone) {
         Instance instance = application.require(instanceName);
-        boolean registerLegacyNames = legacyNamesAvailable(application.deploymentSpec(), instanceName);
+        boolean registerLegacyNames = requiresLegacyNames(application.deploymentSpec(), instanceName);
         Set<ContainerEndpoint> containerEndpoints = new HashSet<>();
-        EndpointList endpoints = endpointsOf(application, instanceName);
+        EndpointList endpoints = declaredEndpointsOf(application);
+        EndpointList globalEndpoints = endpoints.scope(Endpoint.Scope.global);
         // Add endpoints backed by a rotation, and register them in DNS if necessary
         for (var assignedRotation : instance.rotations()) {
             var names = new ArrayList<String>();
-            EndpointList rotationEndpoints = endpoints.named(assignedRotation.endpointId())
-                                                      .requiresRotation();
+            EndpointList rotationEndpoints = globalEndpoints.named(assignedRotation.endpointId())
+                                                            .requiresRotation();
 
             // Skip rotations which do not apply to this zone. Legacy names always point to all zones
             if (!registerLegacyNames && !assignedRotation.regions().contains(zone.region())) {
@@ -276,17 +276,19 @@ public class RoutingController {
 
             // Include rotation ID as a valid name of this container endpoint (required by global routing health checks)
             names.add(assignedRotation.rotationId().asString());
-            containerEndpoints.add(new ContainerEndpoint(assignedRotation.clusterId().value(), names));
+            containerEndpoints.add(new ContainerEndpoint(assignedRotation.clusterId().value(),
+                                                         names));
         }
-        // Add endpoints not backed by a rotation
+        // Add endpoints not backed by a rotation (i.e. other routing methods so that the config server always knows
+        // about global names, even when not using rotations)
         DeploymentId deployment = new DeploymentId(instance.id(), zone);
-        endpoints.not().requiresRotation()
-                 .targets(deployment)
-                 .groupingBy(Endpoint::cluster)
-                 .forEach((clusterId, clusterEndpoints) -> {
-                     containerEndpoints.add(new ContainerEndpoint(clusterId.value(),
-                                                                  clusterEndpoints.mapToList(Endpoint::dnsName)));
-                 });
+        globalEndpoints.not().requiresRotation()
+                       .targets(deployment)
+                       .groupingBy(Endpoint::cluster)
+                       .forEach((clusterId, clusterEndpoints) -> {
+                           containerEndpoints.add(new ContainerEndpoint(clusterId.value(),
+                                                                        clusterEndpoints.mapToList(Endpoint::dnsName)));
+                       });
         return Collections.unmodifiableSet(containerEndpoints);
     }
 
@@ -352,9 +354,8 @@ public class RoutingController {
     private List<Endpoint> computeGlobalEndpoints(RoutingId routingId, ClusterSpec.Id cluster, List<DeploymentId> deployments, DeploymentSpec deploymentSpec) {
         var endpoints = new ArrayList<Endpoint>();
         var directMethods = 0;
-        var zones = deployments.stream().map(DeploymentId::zoneId).collect(Collectors.toList());
         var availableRoutingMethods = routingMethodsOfAll(deployments, deploymentSpec);
-        boolean legacyNamesAvailable = legacyNamesAvailable(deploymentSpec, routingId.instance().instance());
+        boolean legacyNamesAvailable = requiresLegacyNames(deploymentSpec, routingId.instance().instance());
 
         for (var method : availableRoutingMethods) {
             if (method.isDirect() && ++directMethods > 1) {
@@ -386,7 +387,7 @@ public class RoutingController {
     }
 
     /** Whether legacy global DNS names should be available for given application */
-    private static boolean legacyNamesAvailable(DeploymentSpec deploymentSpec, InstanceName instanceName) {
+    private static boolean requiresLegacyNames(DeploymentSpec deploymentSpec, InstanceName instanceName) {
         return deploymentSpec.instance(instanceName)
                              .flatMap(DeploymentInstanceSpec::globalServiceId)
                              .isPresent();
diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/Endpoint.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/Endpoint.java
index 3698c794e8f..5163d7eaafe 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/Endpoint.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/Endpoint.java
@@ -36,6 +36,7 @@ public class Endpoint {
 
     private final EndpointId id;
     private final ClusterSpec.Id cluster;
+    private final Optional<InstanceName> instance;
     private final URI url;
     private final List<Target> targets;
     private final Scope scope;
@@ -81,6 +82,7 @@ public class Endpoint {
         }
         this.id = id;
         this.cluster = cluster;
+        this.instance = instanceName;
         this.url = url;
         this.targets = List.copyOf(targets);
         this.scope = scope;
@@ -124,6 +126,11 @@ public class Endpoint {
         return cluster;
     }
 
+    /** The specific instance this endpoint points to, if any */
+    public Optional<InstanceName> instance() {
+        return instance;
+    }
+
     /** Returns the URL used to access this */
     public URI url() {
         return url;
diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/EndpointList.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/EndpointList.java
index 1ad315545e3..f626d832b6a 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/EndpointList.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/application/EndpointList.java
@@ -3,6 +3,7 @@ package com.yahoo.vespa.hosted.controller.application;
 
 import com.yahoo.collections.AbstractFilteringList;
 import com.yahoo.config.provision.ClusterSpec;
+import com.yahoo.config.provision.InstanceName;
 import com.yahoo.vespa.hosted.controller.api.identifiers.DeploymentId;
 
 import java.util.Collection;
@@ -41,6 +42,12 @@ public class EndpointList extends AbstractFilteringList<Endpoint, EndpointList>
         return matching(endpoint -> endpoint.cluster().equals(cluster));
     }
 
+    /** Returns the subset of endpoints pointing to given instance */
+    public EndpointList instance(InstanceName instance) {
+        return matching(endpoint -> endpoint.instance().isPresent() &&
+                                    endpoint.instance().get().equals(instance));
+    }
+
     /** Returns the subset of endpoints which target all of the given deployments */
     public EndpointList targets(List<DeploymentId> deployments) {
         return matching(endpoint -> endpoint.deployments().containsAll(deployments));
diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/deployment/InternalStepRunner.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/deployment/InternalStepRunner.java
index ee955fa8ff8..577dab69279 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/deployment/InternalStepRunner.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/deployment/InternalStepRunner.java
@@ -451,7 +451,7 @@ public class InternalStepRunner implements StepRunner {
 
     /** Returns true iff all calls to endpoint in the deployment give 100 consecutive 200 OK responses on /status.html. */
     private boolean containersAreUp(ApplicationId id, ZoneId zoneId, DualLogger logger) {
-        var endpoints = controller.routing().zoneEndpointsOf(Set.of(new DeploymentId(id, zoneId)));
+        var endpoints = controller.routing().readZoneEndpointsOf(Set.of(new DeploymentId(id, zoneId)));
         if ( ! endpoints.containsKey(zoneId))
             return false;
 
@@ -477,7 +477,7 @@ public class InternalStepRunner implements StepRunner {
     }
 
     private boolean endpointsAvailable(ApplicationId id, ZoneId zone, DualLogger logger) {
-        var endpoints = controller.routing().zoneEndpointsOf(Set.of(new DeploymentId(id, zone)));
+        var endpoints = controller.routing().readZoneEndpointsOf(Set.of(new DeploymentId(id, zone)));
         if ( ! endpoints.containsKey(zone)) {
             logger.log("Endpoints not yet ready.");
             return false;
@@ -586,7 +586,7 @@ public class InternalStepRunner implements StepRunner {
         deployments.add(new DeploymentId(id.application(), zoneId));
 
         logger.log("Attempting to find endpoints ...");
-        var endpoints = controller.routing().zoneEndpointsOf(deployments);
+        var endpoints = controller.routing().readZoneEndpointsOf(deployments);
         if ( ! endpoints.containsKey(zoneId)) {
             logger.log(WARNING, "Endpoints for the deployment to test vanished again, while it was still active!");
             return Optional.of(error);
diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/application/ApplicationApiHandler.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/application/ApplicationApiHandler.java
index 4144eda212b..0ecf259be1c 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/application/ApplicationApiHandler.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/application/ApplicationApiHandler.java
@@ -1371,7 +1371,7 @@ public class ApplicationApiHandler extends AuditLoggingRequestHandler {
         // Add zone endpoints
         boolean legacyEndpoints = request.getBooleanProperty("includeLegacyEndpoints");
         var endpointArray = response.setArray("endpoints");
-        EndpointList zoneEndpoints = controller.routing().endpointsOf(deploymentId)
+        EndpointList zoneEndpoints = controller.routing().readEndpointsOf(deploymentId)
                                                .scope(Endpoint.Scope.zone);
         if (!legacyEndpoints) {
             zoneEndpoints = zoneEndpoints.not().legacy();
@@ -1379,13 +1379,13 @@ public class ApplicationApiHandler extends AuditLoggingRequestHandler {
         for (var endpoint : controller.routing().directEndpoints(zoneEndpoints, deploymentId.applicationId())) {
             toSlime(endpoint, endpointArray.addObject());
         }
-        // Add global endpoints
-        EndpointList globalEndpoints = controller.routing().endpointsOf(application, deploymentId.applicationId().instance())
-                                                 .targets(deploymentId);
+        // Add declared endpoints
+        EndpointList declaredEndpoints = controller.routing().declaredEndpointsOf(application)
+                                                   .targets(deploymentId);
         if (!legacyEndpoints) {
-            globalEndpoints = globalEndpoints.not().legacy();
+            declaredEndpoints = declaredEndpoints.not().legacy();
         }
-        for (var endpoint : controller.routing().directEndpoints(globalEndpoints, deploymentId.applicationId())) {
+        for (var endpoint : controller.routing().directEndpoints(declaredEndpoints, deploymentId.applicationId())) {
             toSlime(endpoint, endpointArray.addObject());
         }
 
@@ -2061,7 +2061,7 @@ public class ApplicationApiHandler extends AuditLoggingRequestHandler {
         return new SlimeJsonResponse(testConfigSerializer.configSlime(id,
                                                                       type,
                                                                       false,
-                                                                      controller.routing().zoneEndpointsOf(deployments),
+                                                                      controller.routing().readZoneEndpointsOf(deployments),
                                                                       controller.applications().reachableContentClustersByZone(deployments)));
     }
 
diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/routing/RoutingApiHandler.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/routing/RoutingApiHandler.java
index 50fccc19752..df4c31f49a1 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/routing/RoutingApiHandler.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/restapi/routing/RoutingApiHandler.java
@@ -96,7 +96,7 @@ public class RoutingApiHandler extends AuditLoggingRequestHandler {
 
     private HttpResponse endpoints(Path path) {
         var instanceId = instanceFrom(path);
-        var endpoints = controller.routing().endpointsOf(instanceId)
+        var endpoints = controller.routing().readDeclaredEndpointsOf(instanceId)
                 .sortedBy(Comparator.comparing(Endpoint::name))
                 .asList();
 
diff --git a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/routing/RoutingPolicies.java b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/routing/RoutingPolicies.java
index af3171181a2..42557da0e26 100644
--- a/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/routing/RoutingPolicies.java
+++ b/controller-server/src/main/java/com/yahoo/vespa/hosted/controller/routing/RoutingPolicies.java
@@ -133,7 +133,7 @@ public class RoutingPolicies {
         Map<RoutingId, List<RoutingPolicy>> routingTable = instanceRoutingTable(routingPolicies);
         for (Map.Entry<RoutingId, List<RoutingPolicy>> routeEntry : routingTable.entrySet()) {
             RoutingId routingId = routeEntry.getKey();
-            controller.routing().endpointsOf(routingId.instance())
+            controller.routing().readDeclaredEndpointsOf(routingId.instance())
                       .named(routingId.endpointId())
                       .not().requiresRotation()
                       .forEach(endpoint -> updateGlobalDnsOf(endpoint, inactiveZones, routeEntry.getValue()));
@@ -211,7 +211,8 @@ public class RoutingPolicies {
         Map<String, Set<AliasTarget>> targetsByEndpoint = new LinkedHashMap<>();
         for (Map.Entry<RoutingId, List<RoutingPolicy>> routeEntry : routingTable.entrySet()) {
             RoutingId routingId = routeEntry.getKey();
-            EndpointList endpoints = controller.routing().endpointsOf(routingId.application())
+            EndpointList endpoints = controller.routing().readDeclaredEndpointsOf(routingId.application())
+                                               .scope(Endpoint.Scope.region)
                                                .named(routingId.endpointId());
             if (endpoints.isEmpty()) continue;
             if (endpoints.size() > 1) {
@@ -294,7 +295,7 @@ public class RoutingPolicies {
         Set<RoutingId> activeRoutingIds = instanceRoutingIds(allocation);
         removalCandidates.removeAll(activeRoutingIds);
         for (var id : removalCandidates) {
-            EndpointList endpoints = controller.routing().endpointsOf(id.instance())
+            EndpointList endpoints = controller.routing().readDeclaredEndpointsOf(id.instance())
                                                .not().requiresRotation()
                                                .named(id.endpointId());
             NameServiceForwarder forwarder = nameServiceForwarderIn(allocation.deployment.zoneId());
@@ -315,7 +316,7 @@ public class RoutingPolicies {
         for (var id : removalCandidates) {
             TenantAndApplicationId application = TenantAndApplicationId.from(id.instance());
             EndpointList endpoints = controller.routing()
-                                               .endpointsOf(application)
+                                               .readDeclaredEndpointsOf(application)
                                                .named(id.endpointId());
             List<RoutingPolicy> policies = routingTable.get(id);
             for (var policy : policies) {
diff --git a/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/ControllerTest.java b/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/ControllerTest.java
index e2bc1fa305d..30d383f249d 100644
--- a/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/ControllerTest.java
+++ b/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/ControllerTest.java
@@ -255,7 +255,7 @@ public class ControllerTest {
         assertEquals("app1--tenant1.global.vespa.oath.cloud", record.get().name().asString());
         assertEquals("rotation-fqdn-01.", record.get().data().asString());
 
-        List<String> globalDnsNames = tester.controller().routing().endpointsOf(context.instanceId())
+        List<String> globalDnsNames = tester.controller().routing().readEndpointsOf(context.instanceId())
                                             .scope(Endpoint.Scope.global)
                                             .mapToList(Endpoint::dnsName);
         assertEquals(List.of("app1--tenant1.global.vespa.oath.cloud"), globalDnsNames);
@@ -299,7 +299,7 @@ public class ControllerTest {
         assertEquals("app1.tenant1.global.vespa.yahooapis.com", record.get().name().asString());
         assertEquals("rotation-fqdn-01.", record.get().data().asString());
 
-        List<String> globalDnsNames = tester.controller().routing().endpointsOf(context.instanceId())
+        List<String> globalDnsNames = tester.controller().routing().readEndpointsOf(context.instanceId())
                                             .scope(Endpoint.Scope.global)
                                             .mapToList(Endpoint::dnsName);
         assertEquals(List.of("app1--tenant1.global.vespa.oath.cloud",
@@ -610,7 +610,7 @@ public class ControllerTest {
         assertEquals("DeploymentSpec is not stored", DeploymentSpec.empty, context.application().deploymentSpec());
 
         // Verify zone supports shared layer 4 and shared routing methods
-        Set<RoutingMethod> routingMethods = tester.controller().routing().endpointsOf(context.deploymentIdIn(zone))
+        Set<RoutingMethod> routingMethods = tester.controller().routing().readEndpointsOf(context.deploymentIdIn(zone))
                 .asList()
                 .stream()
                 .map(Endpoint::routingMethod)
@@ -875,7 +875,7 @@ public class ControllerTest {
         tester.controllerTester().zoneRegistry()
               .setRoutingMethod(ZoneApiMock.from(zone1), RoutingMethod.shared, RoutingMethod.sharedLayer4)
               .setRoutingMethod(ZoneApiMock.from(zone2), RoutingMethod.shared, RoutingMethod.sharedLayer4);
-        Supplier<Set<RoutingMethod>> routingMethods = () -> tester.controller().routing().endpointsOf(context.deploymentIdIn(zone1))
+        Supplier<Set<RoutingMethod>> routingMethods = () -> tester.controller().routing().readEndpointsOf(context.deploymentIdIn(zone1))
                                                                   .asList()
                                                                   .stream()
                                                                   .map(Endpoint::routingMethod)
@@ -901,7 +901,7 @@ public class ControllerTest {
                                 "application--tenant.global.vespa.oath.cloud"),
                          tester.configServer().containerEndpoints().get(context.deploymentIdIn(zone)));
         }
-        List<String> zoneDnsNames = tester.controller().routing().endpointsOf(context.deploymentIdIn(zone1))
+        List<String> zoneDnsNames = tester.controller().routing().readEndpointsOf(context.deploymentIdIn(zone1))
                                           .scope(Endpoint.Scope.zone)
                                           .mapToList(Endpoint::dnsName);
         assertEquals(List.of("application--tenant.us-west-1.vespa.oath.cloud",
diff --git a/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/rotation/RotationRepositoryTest.java b/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/rotation/RotationRepositoryTest.java
index 910e5943989..b767e8a791f 100644
--- a/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/rotation/RotationRepositoryTest.java
+++ b/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/rotation/RotationRepositoryTest.java
@@ -63,7 +63,7 @@ public class RotationRepositoryTest {
 
         assertEquals(List.of(expected.id()), rotationIds(application.instance().rotations()));
         assertEquals(URI.create("https://app1--tenant1.global.vespa.oath.cloud:4443/"),
-                     tester.controller().routing().endpointsOf(application.instanceId()).primary().get().url());
+                     tester.controller().routing().readDeclaredEndpointsOf(application.instanceId()).primary().get().url());
         try (RotationLock lock = repository.lock()) {
             List<AssignedRotation> rotations = repository.getOrAssignRotations(application.application().deploymentSpec(),
                                                                                application.instance(),
@@ -158,7 +158,7 @@ public class RotationRepositoryTest {
         application2.submit(applicationPackage);
         assertEquals(List.of(new RotationId("foo-1")), rotationIds(application2.instance().rotations()));
         assertEquals("https://cd--app2--tenant2.global.vespa.oath.cloud:4443/",
-                     tester.controller().routing().endpointsOf(application2.instanceId()).primary().get().url().toString());
+                     tester.controller().routing().readDeclaredEndpointsOf(application2.instanceId()).primary().get().url().toString());
     }
 
     @Test
@@ -174,9 +174,9 @@ public class RotationRepositoryTest {
         assertEquals(List.of(new RotationId("foo-1")), rotationIds(instance1.instance().rotations()));
         assertEquals(List.of(new RotationId("foo-2")), rotationIds(instance2.instance().rotations()));
         assertEquals(URI.create("https://instance1--application1--tenant1.global.vespa.oath.cloud:4443/"),
-                     tester.controller().routing().endpointsOf(instance1.instanceId()).primary().get().url());
+                     tester.controller().routing().readDeclaredEndpointsOf(instance1.instanceId()).primary().get().url());
         assertEquals(URI.create("https://instance2--application1--tenant1.global.vespa.oath.cloud:4443/"),
-                     tester.controller().routing().endpointsOf(instance2.instanceId()).primary().get().url());
+                     tester.controller().routing().readDeclaredEndpointsOf(instance2.instanceId()).primary().get().url());
     }
 
     @Test
@@ -194,9 +194,9 @@ public class RotationRepositoryTest {
         assertEquals(List.of(new RotationId("foo-2")), rotationIds(instance2.instance().rotations()));
 
         assertEquals(URI.create("https://instance1--application1--tenant1.global.vespa.oath.cloud:4443/"),
-                     tester.controller().routing().endpointsOf(instance1.instanceId()).primary().get().url());
+                     tester.controller().routing().readDeclaredEndpointsOf(instance1.instanceId()).primary().get().url());
         assertEquals(URI.create("https://instance2--application1--tenant1.global.vespa.oath.cloud:4443/"),
-                     tester.controller().routing().endpointsOf(instance2.instanceId()).primary().get().url());
+                     tester.controller().routing().readDeclaredEndpointsOf(instance2.instanceId()).primary().get().url());
     }
 
     private void assertSingleRotation(Rotation expected, List<AssignedRotation> assignedRotations, RotationRepository repository) {
diff --git a/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/routing/RoutingPoliciesTest.java b/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/routing/RoutingPoliciesTest.java
index afcc5e14d82..c777b659461 100644
--- a/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/routing/RoutingPoliciesTest.java
+++ b/controller-server/src/test/java/com/yahoo/vespa/hosted/controller/routing/RoutingPoliciesTest.java
@@ -789,7 +789,7 @@ public class RoutingPoliciesTest {
                              Map.of(betaZone1, 1));
         assertTrue("Endpoint removed",
                    tester.controllerTester().controller().routing()
-                         .endpointsOf(application)
+                         .readDeclaredEndpointsOf(application)
                          .named(EndpointId.of("a1")).isEmpty());
     }
 
@@ -916,7 +916,7 @@ public class RoutingPoliciesTest {
                                    int loadBalancerId, Map<DeploymentId, Integer> deploymentWeights) {
             Map<String, List<DeploymentId>> deploymentsByDnsName = new HashMap<>();
             for (var deployment : deploymentWeights.keySet()) {
-                EndpointList applicationEndpoints = tester.controller().routing().endpointsOf(application)
+                EndpointList applicationEndpoints = tester.controller().routing().readDeclaredEndpointsOf(application)
                                                           .named(endpointId)
                                                           .targets(deployment)
                                                           .cluster(cluster);
@@ -944,7 +944,7 @@ public class RoutingPoliciesTest {
             Map<String, List<ZoneId>> zonesByRegionEndpoint = new HashMap<>();
             for (var zone : zoneWeights.keySet()) {
                 DeploymentId deployment = new DeploymentId(instance, zone);
-                EndpointList regionEndpoints = tester.controller().routing().endpointsOf(deployment)
+                EndpointList regionEndpoints = tester.controller().routing().readEndpointsOf(deployment)
                                                     .cluster(cluster)
                                                     .scope(Endpoint.Scope.weighted);
                 Endpoint regionEndpoint = regionEndpoints.first().orElseThrow(() -> new IllegalArgumentException("No region endpoint found for " + cluster + " in " + deployment));
@@ -965,7 +965,7 @@ public class RoutingPoliciesTest {
                 latencyTargets.add(latencyTarget);
             });
             List<DeploymentId> deployments = zoneWeights.keySet().stream().map(z -> new DeploymentId(instance, z)).collect(Collectors.toList());
-            String globalEndpoint = tester.controller().routing().endpointsOf(instance)
+            String globalEndpoint = tester.controller().routing().readDeclaredEndpointsOf(instance)
                                           .named(endpointId)
                                           .targets(deployments)
                                           .primary()