fix(endpoint): Do not resolve an endpoint if reference is unknown or …

…invalid

Closes gravitee-io/issues#1515

gravitee-gateway-core/src/main/java/io/gravitee/gateway/core/endpoint/ref/Reference.java

@@ -23,6 +23,8 @@
  */
 public interface Reference {
 
+    String UNKNOWN_REFERENCE = "ref:unknown";
+
     String key();
 
     String name();

gravitee-gateway-core/src/main/java/io/gravitee/gateway/core/endpoint/ref/impl/DefaultReferenceRegister.java

@@ -23,6 +23,9 @@
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -72,6 +75,141 @@ public void provide(TemplateContext context) {
                         entry -> entry.getValue().name(),
                         entry -> entry.getKey() + ':'));
 
-        context.setVariable(TEMPLATE_VARIABLE_KEY, refs);
+        context.setVariable(TEMPLATE_VARIABLE_KEY, new EndpointReferenceMap(refs));
+    }
+
+    private static class EndpointReferenceMap implements Map<String, String> {
+
+        private final Map<String, String> wrapped;
+
+        EndpointReferenceMap(Map<String, String> wrapped) {
+            this.wrapped = wrapped;
+        }
+
+        @Override
+        public int size() {
+            return wrapped.size();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return wrapped.isEmpty();
+        }
+
+        @Override
+        public boolean containsKey(Object key) {
+            return wrapped.containsKey(key);
+        }
+
+        @Override
+        public boolean containsValue(Object value) {
+            return wrapped.containsValue(value);
+        }
+
+        @Override
+        public String get(Object key) {
+            String reference = wrapped.get(key);
+            return (reference != null) ? reference : Reference.UNKNOWN_REFERENCE;
+        }
+
+        @Override
+        public String put(String key, String value) {
+            return wrapped.put(key, value);
+        }
+
+        @Override
+        public String remove(Object key) {
+            return wrapped.remove(key);
+        }
+
+        @Override
+        public void putAll(Map<? extends String, ? extends String> m) {
+            wrapped.putAll(m);
+        }
+
+        @Override
+        public void clear() {
+            wrapped.clear();
+        }
+
+        @Override
+        public Set<String> keySet() {
+            return wrapped.keySet();
+        }
+
+        @Override
+        public Collection<String> values() {
+            return wrapped.values();
+        }
+
+        @Override
+        public Set<Entry<String, String>> entrySet() {
+            return wrapped.entrySet();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            return wrapped.equals(o);
+        }
+
+        @Override
+        public int hashCode() {
+            return wrapped.hashCode();
+        }
+
+        @Override
+        public String getOrDefault(Object key, String defaultValue) {
+            return wrapped.getOrDefault(key, defaultValue);
+        }
+
+        @Override
+        public void forEach(BiConsumer<? super String, ? super String> action) {
+            wrapped.forEach(action);
+        }
+
+        @Override
+        public void replaceAll(BiFunction<? super String, ? super String, ? extends String> function) {
+            wrapped.replaceAll(function);
+        }
+
+        @Override
+        public String putIfAbsent(String key, String value) {
+            return wrapped.putIfAbsent(key, value);
+        }
+
+        @Override
+        public boolean remove(Object key, Object value) {
+            return wrapped.remove(key, value);
+        }
+
+        @Override
+        public boolean replace(String key, String oldValue, String newValue) {
+            return wrapped.replace(key, oldValue, newValue);
+        }
+
+        @Override
+        public String replace(String key, String value) {
+            return wrapped.replace(key, value);
+        }
+
+        @Override
+        public String computeIfAbsent(String key, Function<? super String, ? extends String> mappingFunction) {
+            return wrapped.computeIfAbsent(key, mappingFunction);
+        }
+
+        @Override
+        public String computeIfPresent(String key, BiFunction<? super String, ? super String, ? extends String> remappingFunction) {
+            return wrapped.computeIfPresent(key, remappingFunction);
+        }
+
+        @Override
+        public String compute(String key, BiFunction<? super String, ? super String, ? extends String> remappingFunction) {
+            return wrapped.compute(key, remappingFunction);
+        }
+
+        @Override
+        public String merge(String key, String value, BiFunction<? super String, ? super String, ? extends String> remappingFunction) {
+            return wrapped.merge(key, value, remappingFunction);
+        }
     }
 }

gravitee-gateway-core/src/main/java/io/gravitee/gateway/core/endpoint/resolver/impl/TargetEndpointResolver.java

@@ -119,16 +119,19 @@ private ResolvedEndpoint selectUserDefinedEndpoint(Request serverRequest, String
                 Endpoint endpoint = reference.endpoint();
 
                 return createEndpoint(endpoint, encodedTarget.replaceFirst(sRef + ':', endpoint.target()));
+            } else if (encodedTarget.startsWith(Reference.UNKNOWN_REFERENCE)) {
+                return null;
             } else {
-                // Try to match an endpoint according to the target URL
+                // When the user selected endpoint which is not defined (according to the given target), the gateway
+                // is always returning the first endpoints reference and took into account its configuration.
                 Collection<Reference> endpoints = referenceRegister.referencesByType(EndpointReference.class);
                 Reference reference = endpoints
                         .stream()
                         .filter(endpointEntry -> encodedTarget.startsWith(endpointEntry.endpoint().target()))
                         .findFirst()
                         .orElse(endpoints.iterator().next());
 
-                return createEndpoint(reference.endpoint(), encodedTarget);
+                return (reference != null) ? createEndpoint(reference.endpoint(), encodedTarget) : null;
             }
         }
     }

gravitee-gateway-core/src/main/java/io/gravitee/gateway/core/invoker/EndpointInvoker.java

@@ -58,6 +58,7 @@ public class EndpointInvoker implements Invoker {
     public Request invoke(ExecutionContext executionContext, Request serverRequest, ReadStream<Buffer> stream, Handler<ProxyConnection> connectionHandler) {
         EndpointResolver.ResolvedEndpoint endpoint = endpointResolver.resolve(serverRequest, executionContext);
 
+        // Endpoint can be null if none endpoint can be selected or if the selected endpoint is unavailable
         if (endpoint == null) {
             DirectProxyConnection statusOnlyConnection = new DirectProxyConnection(HttpStatusCode.SERVICE_UNAVAILABLE_503);
             connectionHandler.handle(statusOnlyConnection);

gravitee-gateway-core/src/test/java/io/gravitee/gateway/core/endpoint/resolver/impl/TargetEndpointResolverTest.java

@@ -78,7 +78,6 @@ public void shouldResolveUserDefinedEndpoint_selectFirstEndpoint() {
                 .thenAnswer(invocation -> Collections.singleton(new EndpointReference(endpoint)));
 
         EndpointResolver.ResolvedEndpoint resolvedEndpoint = resolver.resolve(serverRequest, executionContext);
-
         Assert.assertEquals(targetUri, resolvedEndpoint.getUri());
     }
 

gravitee-gateway-http/src/main/java/io/gravitee/gateway/http/connector/VertxHttpClient.java

@@ -210,8 +210,6 @@ private HttpMethod convert(io.gravitee.common.http.HttpMethod httpMethod) {
 
     @Override
     protected void doStart() throws Exception {
-        // TODO: Prepare HttpClientOptions according to the endpoint to improve performance when creating a new
-        // instance of the Vertx client
         httpClientOptions = new HttpClientOptions();
 
         httpClientOptions.setPipelining(endpoint.getHttpClientOptions().isPipelining());

gravitee-gateway-standalone/gravitee-gateway-standalone-container/src/test/resources/io/gravitee/gateway/standalone/dynamic-routing.json

@@ -7,7 +7,7 @@
     "endpoints": [
       {
         "name": "default",
-        "target": "http://bad_url_but_overriden:8080/team"
+        "target": "http://localhost:8080/team"
       }
     ],
     "strip_context_path": false,