Integrate http binding with validators

runtime/binding-http/pom.xml

@@ -137,7 +137,7 @@
                   </fileMappers>
                 </artifactItem>
               </artifactItems>
-              <includes>io/aklivity/zilla/specs/binding/http/schema/http*.schema.patch.json</includes>
+              <includes>io/aklivity/zilla/specs/binding/http/schema/http.schema.patch.json</includes>
               <outputDirectory>${project.build.directory}/classes</outputDirectory>
             </configuration>
           </execution>

runtime/binding-http/src/main/java/io/aklivity/zilla/runtime/binding/http/config/HttpRequestConfig.java

@@ -35,13 +35,13 @@ public enum Method
         TRACE
     }
 
-    public String path;
-    public Method method;
-    public List<String> contentType;
-    public List<HttpParamConfig> headers;
-    public List<HttpParamConfig> pathParams;
-    public List<HttpParamConfig> queryParams;
-    public ValidatorConfig content;
+    public final String path;
+    public final Method method;
+    public final List<String> contentType;
+    public final List<HttpParamConfig> headers;
+    public final List<HttpParamConfig> pathParams;
+    public final List<HttpParamConfig> queryParams;
+    public final ValidatorConfig content;
 
     public HttpRequestConfig(
         String path,

runtime/binding-http/src/main/java/io/aklivity/zilla/runtime/binding/http/internal/HttpBinding.java

@@ -41,10 +41,7 @@ public String name()
     @Override
     public URL type()
     {
-        String patch = config.requestValidators()
-            ? "schema/http.with.validators.schema.patch.json"
-            : "schema/http.schema.patch.json";
-        return getClass().getResource(patch);
+        return getClass().getResource("schema/http.schema.patch.json");
     }
 
     @Override

runtime/binding-http/src/main/java/io/aklivity/zilla/runtime/binding/http/internal/HttpConfiguration.java

@@ -35,7 +35,6 @@ public class HttpConfiguration extends Configuration
     public static final IntPropertyDef HTTP_MAX_CONCURRENT_APPLICATION_HEADERS;
     public static final PropertyDef<String> HTTP_SERVER_HEADER;
     public static final PropertyDef<String> HTTP_USER_AGENT_HEADER;
-    public static final BooleanPropertyDef HTTP_REQUEST_VALIDATORS;
 
     private static final ConfigurationDef HTTP_CONFIG;
 
@@ -53,7 +52,6 @@ public class HttpConfiguration extends Configuration
         HTTP_MAX_CONCURRENT_STREAMS_CLEANUP = config.property("max.concurrent.streams.cleanup", 1000);
         HTTP_STREAMS_CLEANUP_DELAY = config.property("streams.cleanup.delay", 100);
         HTTP_MAX_CONCURRENT_APPLICATION_HEADERS = config.property("max.concurrent.application.headers", 10000);
-        HTTP_REQUEST_VALIDATORS = config.property("request.validators", false);
         HTTP_CONFIG = config;
     }
 
@@ -115,11 +113,6 @@ public int maxConcurrentApplicationHeaders()
         return HTTP_MAX_CONCURRENT_APPLICATION_HEADERS.getAsInt(this);
     }
 
-    public boolean requestValidators()
-    {
-        return HTTP_REQUEST_VALIDATORS.getAsBoolean(this);
-    }
-
     public String16FW serverHeader()
     {
         return serverHeader;

runtime/binding-http/src/main/java/io/aklivity/zilla/runtime/binding/http/internal/config/HttpBindingConfig.java

@@ -19,28 +19,49 @@
 import static java.util.EnumSet.allOf;
 import static java.util.stream.Collectors.toList;
 
+import java.util.HashMap;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.SortedSet;
+import java.util.TreeMap;
 import java.util.TreeSet;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.ToLongFunction;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import org.agrona.DirectBuffer;
+import org.agrona.collections.MutableBoolean;
+import org.agrona.collections.Object2ObjectHashMap;
+
 import io.aklivity.zilla.runtime.binding.http.config.HttpAccessControlConfig;
 import io.aklivity.zilla.runtime.binding.http.config.HttpCredentialsConfig;
 import io.aklivity.zilla.runtime.binding.http.config.HttpOptionsConfig;
+import io.aklivity.zilla.runtime.binding.http.config.HttpParamConfig;
 import io.aklivity.zilla.runtime.binding.http.config.HttpPatternConfig;
+import io.aklivity.zilla.runtime.binding.http.config.HttpRequestConfig;
 import io.aklivity.zilla.runtime.binding.http.config.HttpVersion;
+import io.aklivity.zilla.runtime.binding.http.internal.types.HttpHeaderFW;
+import io.aklivity.zilla.runtime.binding.http.internal.types.String16FW;
+import io.aklivity.zilla.runtime.binding.http.internal.types.String8FW;
+import io.aklivity.zilla.runtime.binding.http.internal.types.stream.HttpBeginExFW;
 import io.aklivity.zilla.runtime.engine.config.BindingConfig;
 import io.aklivity.zilla.runtime.engine.config.KindConfig;
+import io.aklivity.zilla.runtime.engine.config.ValidatorConfig;
+import io.aklivity.zilla.runtime.engine.validator.Validator;
 
 public final class HttpBindingConfig
 {
     private static final Function<Function<String, String>, String> DEFAULT_CREDENTIALS = f -> null;
     private static final SortedSet<HttpVersion> DEFAULT_VERSIONS = new TreeSet<>(allOf(HttpVersion.class));
     private static final HttpAccessControlConfig DEFAULT_ACCESS_CONTROL =
             HttpAccessControlConfig.builder().policy(SAME_ORIGIN).build();
+    private static final String8FW HEADER_CONTENT_TYPE = new String8FW("content-type");
+    private static final String8FW HEADER_METHOD = new String8FW(":method");
+    private static final String8FW HEADER_PATH = new String8FW(":path");
+    private static final HttpQueryStringComparator QUERY_STRING_COMPARATOR = new HttpQueryStringComparator();
 
     public final long id;
     public final String name;
@@ -49,9 +70,17 @@ public final class HttpBindingConfig
     public final List<HttpRouteConfig> routes;
     public final ToLongFunction<String> resolveId;
     public final Function<Function<String, String>, String> credentials;
+    public final List<HttpRequestType> requests;
 
     public HttpBindingConfig(
         BindingConfig binding)
+    {
+        this(binding, null);
+    }
+
+    public HttpBindingConfig(
+        BindingConfig binding,
+        BiFunction<ValidatorConfig, ToLongFunction<String>, Validator> createValidator)
     {
         this.id = binding.id;
         this.name = binding.name;
@@ -61,6 +90,7 @@ public HttpBindingConfig(
         this.resolveId = binding.resolveId;
         this.credentials = options != null && options.authorization != null ?
                 asAccessor(options.authorization.credentials) : DEFAULT_CREDENTIALS;
+        this.requests = createValidator == null ? null : createRequestTypes(createValidator);
     }
 
     public HttpRouteConfig resolve(
@@ -164,6 +194,188 @@ private Function<Function<String, String>, String> asAccessor(
         return accessor;
     }
 
+    private List<HttpRequestType> createRequestTypes(
+        BiFunction<ValidatorConfig, ToLongFunction<String>, Validator> createValidator)
+    {
+        List<HttpRequestType> requestTypes = new LinkedList<>();
+        if (this.options != null && this.options.requests != null)
+        {
+            for (HttpRequestConfig request : this.options.requests)
+            {
+                Map<String8FW, Validator> headers = new HashMap<>();
+                if (request.headers != null)
+                {
+                    for (HttpParamConfig header : request.headers)
+                    {
+                        headers.put(new String8FW(header.name), createValidator.apply(header.validator, this.resolveId));
+                    }
+                }
+                Map<String, Validator> pathParams = new Object2ObjectHashMap<>();
+                if (request.pathParams != null)
+                {
+                    for (HttpParamConfig pathParam : request.pathParams)
+                    {
+                        pathParams.put(pathParam.name, createValidator.apply(pathParam.validator, this.resolveId));
+                    }
+                }
+                Map<String, Validator> queryParams = new TreeMap<>(QUERY_STRING_COMPARATOR);
+                if (request.queryParams != null)
+                {
+                    for (HttpParamConfig queryParam : request.queryParams)
+                    {
+                        queryParams.put(queryParam.name, createValidator.apply(queryParam.validator, this.resolveId));
+                    }
+                }
+                Validator content = createValidator.apply(request.content, this.resolveId);
+                HttpRequestType requestType = HttpRequestType.builder()
+                    .path(request.path)
+                    .method(request.method)
+                    .contentType(request.contentType)
+                    .headers(headers)
+                    .pathParams(pathParams)
+                    .queryParams(queryParams)
+                    .content(content)
+                    .build();
+                requestTypes.add(requestType);
+            }
+        }
+        return requestTypes;
+    }
+
+    public HttpRequestType resolveRequestType(
+        HttpBeginExFW beginEx)
+    {
+        HttpRequestType result = null;
+        if (requests != null && !requests.isEmpty())
+        {
+            String path = resolveHeaderValue(beginEx, HEADER_PATH);
+            String method = resolveHeaderValue(beginEx, HEADER_METHOD);
+            String contentType = resolveHeaderValue(beginEx, HEADER_CONTENT_TYPE);
+            for (HttpRequestType requestType : requests)
+            {
+                if (matchMethod(requestType, method) &&
+                    matchContentType(requestType, contentType) &&
+                    matchPath(requestType, path))
+                {
+                    result = requestType;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    private boolean matchMethod(
+        HttpRequestType requestType,
+        String method)
+    {
+        return method == null || requestType.method == null || method.equals(requestType.method.name());
+    }
+
+    private boolean matchContentType(
+        HttpRequestType requestType,
+        String contentType)
+    {
+        return contentType == null || requestType.contentType == null || requestType.contentType.contains(contentType);
+    }
+
+    private boolean matchPath(
+        HttpRequestType requestType,
+        String path)
+    {
+        return requestType.pathMatcher.reset(path).matches();
+    }
+
+    public boolean validateHeaders(
+        HttpRequestType requestType,
+        HttpBeginExFW beginEx)
+    {
+        String path = beginEx.headers().matchFirst(h -> h.name().equals(HEADER_PATH)).value().asString();
+        return requestType == null ||
+            validateHeaderValues(requestType, beginEx) &&
+            validatePathParams(requestType, path) &&
+            validateQueryParams(requestType, path);
+    }
+
+    private boolean validateHeaderValues(
+        HttpRequestType requestType,
+        HttpBeginExFW beginEx)
+    {
+        MutableBoolean valid = new MutableBoolean(true);
+        if (requestType != null && requestType.headers != null)
+        {
+            beginEx.headers().forEach(header ->
+            {
+                if (valid.value)
+                {
+                    Validator validator = requestType.headers.get(header.name());
+                    if (validator != null)
+                    {
+                        String16FW value = header.value();
+                        valid.value &= validator.read(value.value(), value.offset(), value.length());
+                    }
+                }
+            });
+        }
+        return valid.value;
+    }
+
+    private boolean validatePathParams(
+        HttpRequestType requestType,
+        String path)
+    {
+        Matcher matcher = requestType.pathMatcher.reset(path);
+        boolean matches = matcher.matches();
+        assert matches;
+
+        boolean valid = true;
+        for (String name : requestType.pathParams.keySet())
+        {
+            String value = matcher.group(name);
+            if (value != null)
+            {
+                String8FW value0 = new String8FW(value);
+                Validator validator = requestType.pathParams.get(name);
+                if (!validator.read(value0.value(), value0.offset(), value0.length()))
+                {
+                    valid = false;
+                    break;
+                }
+            }
+        }
+        return valid;
+    }
+
+    private boolean validateQueryParams(
+        HttpRequestType requestType,
+        String path)
+    {
+        Matcher matcher = requestType.queryMatcher.reset(path);
+        boolean valid = true;
+        while (valid && matcher.find())
+        {
+            String name = matcher.group(1);
+            Validator validator = requestType.queryParams.get(name);
+            if (validator != null)
+            {
+                String8FW value = new String8FW(matcher.group(2));
+                valid &= validator.read(value.value(), value.offset(), value.length());
+            }
+        }
+        return valid;
+    }
+
+    public boolean validateContent(
+        HttpRequestType requestType,
+        DirectBuffer buffer,
+        int index,
+        int length)
+    {
+        return requestType == null ||
+            requestType.content == null ||
+            requestType.content.read(buffer, index, length);
+    }
+
     private static Function<Function<String, String>, String> orElseIfNull(
             Function<Function<String, String>, String> first,
             Function<Function<String, String>, String> second)
@@ -174,4 +386,17 @@ private static Function<Function<String, String>, String> orElseIfNull(
             return result != null ? result : second.apply(hs);
         };
     }
+
+    private static String resolveHeaderValue(
+        HttpBeginExFW beginEx,
+        String8FW headerName)
+    {
+        String result = null;
+        HttpHeaderFW header = beginEx.headers().matchFirst(h -> headerName.equals(h.name()));
+        if (header != null)
+        {
+            result = header.value().asString();
+        }
+        return result;
+    }
 }