🚧 Remove strategy, Add Drop match

This commit is contained in:
2026-06-28 18:21:26 +02:00
parent fc2454061f
commit 30665fdaa5
16 changed files with 113 additions and 163 deletions
@@ -7,6 +7,7 @@ import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.http.HttpServerResponse; import io.vertx.core.http.HttpServerResponse;
import jakarta.enterprise.context.ApplicationScoped; import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject; import jakarta.inject.Inject;
import jakarta.ws.rs.core.HttpHeaders;
import org.eclipse.microprofile.config.inject.ConfigProperty; import org.eclipse.microprofile.config.inject.ConfigProperty;
import java.util.Set; import java.util.Set;
@@ -14,6 +15,8 @@ import java.util.Set;
@ApplicationScoped @ApplicationScoped
public class LogoutService public class LogoutService
{ {
private static final String SESSION_COOKIE_NAME = "session";
private static final String IDENTITY_COOKIE_NAME = "identity";
private static final String EMPTY = ""; private static final String EMPTY = "";
@ConfigProperty(name = "oidc.proxy.logout.redirect.url") @ConfigProperty(name = "oidc.proxy.logout.redirect.url")
@@ -24,16 +27,12 @@ public class LogoutService
public void logout(HttpServerRequest request, HttpServerResponse response) public void logout(HttpServerRequest request, HttpServerResponse response)
{ {
String sessionId = getSessionId(request.cookies()); sessionCache.remove(getSessionId(request.cookies()));
if (sessionId != null)
{
sessionCache.remove(sessionId);
}
response.addCookie(Cookie.cookie("session", EMPTY).setMaxAge(0).setPath("/").setHttpOnly(true).setSecure(true)); response.addCookie(Cookie.cookie(SESSION_COOKIE_NAME, EMPTY).setMaxAge(0).setPath("/").setHttpOnly(true).setSecure(true));
response.addCookie(Cookie.cookie("identity", EMPTY).setMaxAge(0).setPath("/").setHttpOnly(false).setSecure(true)); response.addCookie(Cookie.cookie(IDENTITY_COOKIE_NAME, EMPTY).setMaxAge(0).setPath("/").setHttpOnly(false).setSecure(true));
response.setStatusCode(302); response.setStatusCode(302);
response.putHeader("Location", logoutRedirectUrl); response.putHeader(HttpHeaders.LOCATION, logoutRedirectUrl);
response.send(); response.send();
} }
@@ -41,7 +40,7 @@ public class LogoutService
{ {
for (Cookie cookie : cookies) for (Cookie cookie : cookies)
{ {
if ("session".equals(cookie.getName())) if (SESSION_COOKIE_NAME.equals(cookie.getName()))
{ {
return cookie.getValue(); return cookie.getValue();
} }
@@ -5,15 +5,16 @@ import dev.dinauer.oidcproxy.proxy.AccessLog;
import dev.dinauer.oidcproxy.proxy.ForwardService; import dev.dinauer.oidcproxy.proxy.ForwardService;
import dev.dinauer.oidcproxy.proxy.ResponseHandler; import dev.dinauer.oidcproxy.proxy.ResponseHandler;
import dev.dinauer.oidcproxy.proxy.TimedHttpResponse; import dev.dinauer.oidcproxy.proxy.TimedHttpResponse;
import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import dev.dinauer.oidcproxy.proxy.exception.ProxyHttpException; import dev.dinauer.oidcproxy.proxy.exception.ProxyHttpException;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException; import java.io.IOException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException; import java.net.ConnectException;
import java.net.http.HttpConnectTimeoutException;
import dev.dinauer.oidcproxy.startup.PathConverter; import dev.dinauer.oidcproxy.startup.PathConverter;
import dev.dinauer.oidcproxy.startup.ProxyRoute; import dev.dinauer.oidcproxy.startup.ProxyRoute;
import dev.dinauer.oidcproxy.startup.RouteService; import dev.dinauer.oidcproxy.startup.RouteService;
import io.quarkus.vertx.web.Route; import io.quarkus.vertx.web.Route;
import io.smallrye.common.annotation.Blocking; import io.smallrye.common.annotation.Blocking;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.ext.web.RoutingContext; import io.vertx.ext.web.RoutingContext;
import jakarta.enterprise.context.ApplicationScoped; import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject; import jakarta.inject.Inject;
@@ -21,8 +22,9 @@ import jakarta.ws.rs.core.Context;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.net.http.HttpResponse; import java.util.LinkedList;
import java.util.*; import java.util.List;
import java.util.Optional;
@ApplicationScoped @ApplicationScoped
public class Resource public class Resource
@@ -44,25 +46,25 @@ public class Resource
@Inject @Inject
AccessLog accessLog; AccessLog accessLog;
@Route(path = "/auth/callback", order = 0) @Route(path = "/_auth/callback", order = 0)
@Blocking @Blocking
public void callback(@Context RoutingContext context) public void callback(@Context RoutingContext context)
{ {
callbackService.get(context.response(), context.request()); callbackService.handleCodeExchange(context.response(), context.request());
} }
@Route(path = "/auth/logout", order = 1) @Route(path = "/_auth/logout", order = 1)
@Blocking @Blocking
public void logout(@Context RoutingContext context) public void logout(@Context RoutingContext context)
{ {
logoutService.logout(context.request(), context.response()); logoutService.logout(context.request(), context.response());
} }
@Route(path = "/api/*", order = 2) @Route(path = "/*", order = 2)
@Blocking @Blocking
public void proxy(@Context RoutingContext context) public void proxy(@Context RoutingContext context)
{ {
String path = dropPrefix(context.request().path(), "/api"); String path = context.request().path();
Optional<ProxyRoute> match = routeService.match(path); Optional<ProxyRoute> match = routeService.match(path);
if (match.isPresent()) if (match.isPresent())
{ {
@@ -78,10 +80,14 @@ public class Resource
private void route(RoutingContext context, String path, ProxyRoute route) private void route(RoutingContext context, String path, ProxyRoute route)
{ {
List<String> requestSegments = PathConverter.toSegments(path); List<String> requestSegments = PathConverter.toSegments(path);
if (route.dropMatch())
{
requestSegments = new LinkedList<>(requestSegments.subList(route.segments().size(), requestSegments.size()));
}
try try
{ {
String targetURI = route.target() + PathConverter.toPath(requestSegments); String targetURI = route.target() + PathConverter.toPath(requestSegments);
TimedHttpResponse<byte[]> response = forwardService.send(context, targetURI, route.strategy()); TimedHttpResponse<byte[]> response = forwardService.send(context, targetURI);
accessLog.log(AccessLog.Type.INFO, context, PathConverter.toPath(requestSegments), route.target(), response.response().statusCode(), response.time()); accessLog.log(AccessLog.Type.INFO, context, PathConverter.toPath(requestSegments), route.target(), response.response().statusCode(), response.time());
ResponseHandler.success(context, response.response()); ResponseHandler.success(context, response.response());
} }
@@ -90,28 +96,31 @@ public class Resource
accessLog.log(AccessLog.Type.ERROR, context, PathConverter.toPath(requestSegments), route.target(), e.getStatusCode(), e.getTime()); accessLog.log(AccessLog.Type.ERROR, context, PathConverter.toPath(requestSegments), route.target(), e.getStatusCode(), e.getTime());
ResponseHandler.error(context, e.getStatusCode()); ResponseHandler.error(context, e.getStatusCode());
} }
catch (TokenNotFoundException | SessionNotFoundException e) catch (ProxyAuthenticationFailedException e)
{ {
LOG.error("Token / Session not found.", e); LOG.error("Proxy authentication failed.", e);
ResponseHandler.error(context, 401); ResponseHandler.error(context, 401);
} }
catch (HttpConnectTimeoutException e)
{
LOG.error("Upstream connection timed out, returning 504.", e);
ResponseHandler.error(context, 504);
}
catch (ConnectException e)
{
LOG.error("Upstream not reachable, returning 502.", e);
ResponseHandler.error(context, 502);
}
catch (InterruptedException e) catch (InterruptedException e)
{ {
LOG.error("Proxy request was interrupted, returning 503.", e); LOG.error("Proxy request was interrupted, returning 503.", e);
Thread.currentThread().interrupt(); Thread.currentThread().interrupt();
ResponseHandler.error(context, 503); ResponseHandler.error(context, 503);
} }
catch (Exception e) catch (IOException e)
{ {
LOG.error("IO error during proxy request, returning 502.", e);
ResponseHandler.error(context, 502); ResponseHandler.error(context, 502);
throw new RuntimeException(e);
} }
} }
private String dropPrefix(String pathRaw, String prefixRaw)
{
List<String> path = PathConverter.toSegments(pathRaw);
List<String> prefix = PathConverter.toSegments(prefixRaw);
return PathConverter.toPath(new LinkedList<>(path.subList(prefix.size(), path.size())));
}
} }
@@ -10,8 +10,6 @@ import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject; import jakarta.inject.Inject;
import org.eclipse.microprofile.config.inject.ConfigProperty; import org.eclipse.microprofile.config.inject.ConfigProperty;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.ZonedDateTime; import java.time.ZonedDateTime;
@ApplicationScoped @ApplicationScoped
@@ -26,7 +24,7 @@ public class CallbackService
@ConfigProperty(name = "oidc.proxy.client.redirect") @ConfigProperty(name = "oidc.proxy.client.redirect")
String redirectURI; String redirectURI;
public void get(HttpServerResponse response, HttpServerRequest request) public void handleCodeExchange(HttpServerResponse response, HttpServerRequest request)
{ {
String code = request.params().get("code"); String code = request.params().get("code");
TokenResponse oidcResponse = client.exchangeAuthorizationCode(code); TokenResponse oidcResponse = client.exchangeAuthorizationCode(code);
@@ -1,8 +1,7 @@
package dev.dinauer.oidcproxy.proxy; package dev.dinauer.oidcproxy.proxy;
import dev.dinauer.oidcproxy.proxy.exception.ProxyHttpException; import dev.dinauer.oidcproxy.proxy.exception.ProxyHttpException;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException; import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.session.SessionCache; import dev.dinauer.oidcproxy.session.SessionCache;
import dev.dinauer.oidcproxy.proxy.header.HeaderFilter; import dev.dinauer.oidcproxy.proxy.header.HeaderFilter;
import dev.dinauer.oidcproxy.request.HttpRequestBuilder; import dev.dinauer.oidcproxy.request.HttpRequestBuilder;
@@ -24,13 +23,13 @@ public class ForwardService
@Inject @Inject
HeaderFilter headerFilter; HeaderFilter headerFilter;
public TimedHttpResponse<byte[]> send(RoutingContext context, String route, String strategy) throws IOException, InterruptedException, ProxyHttpException, TokenNotFoundException, SessionNotFoundException public TimedHttpResponse<byte[]> send(RoutingContext context, String route) throws IOException, InterruptedException, ProxyHttpException, ProxyAuthenticationFailedException
{ {
HttpRequestBuilder builder = HttpRequestBuilder.create(); HttpRequestBuilder builder = HttpRequestBuilder.create();
builder.setUri(route); builder.setUri(route);
builder.setParams(context.request().params().entries()); builder.setParams(context.request().params().entries());
builder.setMethod(context.request().method().toString()); builder.setMethod(context.request().method().toString());
builder.setHeaders(headerFilter.filter(context.request(), strategy)); builder.setHeaders(headerFilter.filter(context.request()));
builder.setBody(extractBody(context)); builder.setBody(extractBody(context));
long start = System.currentTimeMillis(); long start = System.currentTimeMillis();
@@ -42,7 +41,10 @@ public class ForwardService
{ {
return new TimedHttpResponse<>(time, response); return new TimedHttpResponse<>(time, response);
} }
throw new ProxyHttpException(time, response.statusCode()); else
{
throw new ProxyHttpException(time, response.statusCode());
}
} }
private byte[] extractBody(RoutingContext context) private byte[] extractBody(RoutingContext context)
@@ -0,0 +1,9 @@
package dev.dinauer.oidcproxy.proxy.exception;
public class ProxyAuthenticationFailedException extends Exception
{
public ProxyAuthenticationFailedException()
{
super();
}
}
@@ -1,8 +0,0 @@
package dev.dinauer.oidcproxy.proxy.exception;
public class SessionNotFoundException extends Exception
{
public SessionNotFoundException()
{
}
}
@@ -1,9 +0,0 @@
package dev.dinauer.oidcproxy.proxy.exception;
public class TokenNotFoundException extends Exception
{
public TokenNotFoundException()
{
super();
}
}
@@ -1,37 +1,66 @@
package dev.dinauer.oidcproxy.proxy.header; package dev.dinauer.oidcproxy.proxy.header;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException; import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.proxy.header.strategy.OidcStrategy;
import dev.dinauer.oidcproxy.session.SessionCache; import dev.dinauer.oidcproxy.session.SessionCache;
import io.quarkus.security.UnauthorizedException;
import io.vertx.core.http.Cookie; import io.vertx.core.http.Cookie;
import io.vertx.core.http.HttpServerRequest; import io.vertx.core.http.HttpServerRequest;
import jakarta.enterprise.context.ApplicationScoped; import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject; import jakarta.inject.Inject;
import jakarta.ws.rs.BadRequestException;
import org.apache.commons.lang3.Strings;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.Set;
@ApplicationScoped @ApplicationScoped
public class HeaderFilter public class HeaderFilter
{ {
private static final String AUTH_HEADER = "Authorization";
private static final List<String> HOP2HOP = List.of("keep-alive", "transfer-encoding", "te", "connection", "trailer", "upgrade", "proxy-authenticate", "proxy-authorization"); private static final List<String> HOP2HOP = List.of("keep-alive", "transfer-encoding", "te", "connection", "trailer", "upgrade", "proxy-authenticate", "proxy-authorization");
@Inject @Inject
OidcStrategy oidcStrategy; SessionCache sessionCache;
public List<Map.Entry<String, String>> filter(HttpServerRequest request, String strategy) throws TokenNotFoundException, SessionNotFoundException public List<Map.Entry<String, String>> filter(HttpServerRequest request) throws ProxyAuthenticationFailedException
{ {
List<Map.Entry<String, String>> headers = filterHop2HopHeaders(request.headers().entries()); List<Map.Entry<String, String>> headers = filterHop2HopHeaders(request.headers().entries());
if ("OIDC".equals(strategy)) Optional<String> token = getAccessToken(request);
if (!hasAuthHeader(headers) && token.isPresent())
{ {
headers = oidcStrategy.filter(request, headers); headers.add(Map.entry(AUTH_HEADER, String.format("Bearer %s", token.get())));
} }
return headers; return headers;
} }
private Optional<String> getAccessToken(HttpServerRequest request) throws ProxyAuthenticationFailedException
{
Set<Cookie> sessions = request.cookies("session");
if (sessions.isEmpty())
{
return Optional.empty();
}
if (sessions.size() == 1)
{
return Optional.of(sessionCache.get(sessions.iterator().next().getValue()));
}
throw new BadRequestException();
}
private boolean hasAuthHeader(List<Map.Entry<String, String>> headers)
{
for (Map.Entry<String, String> header : headers)
{
if (Strings.CI.equals(AUTH_HEADER, header.getKey()))
{
return true;
}
}
return false;
}
private List<Map.Entry<String, String>> filterHop2HopHeaders(List<Map.Entry<String, String>> input) private List<Map.Entry<String, String>> filterHop2HopHeaders(List<Map.Entry<String, String>> input)
{ {
List<Map.Entry<String, String>> result = new LinkedList<>(); List<Map.Entry<String, String>> result = new LinkedList<>();
@@ -1,15 +0,0 @@
package dev.dinauer.oidcproxy.proxy.header.strategy;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.List;
import java.util.Map;
@ApplicationScoped
public class NoneStrategy
{
public List<Map.Entry<String, String>> filter(List<Map.Entry<String, String>> input)
{
return input;
}
}
@@ -1,65 +0,0 @@
package dev.dinauer.oidcproxy.proxy.header.strategy;
import dev.dinauer.oidcproxy.proxy.exception.SessionNotFoundException;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException;
import dev.dinauer.oidcproxy.session.SessionCache;
import io.quarkus.security.UnauthorizedException;
import io.vertx.core.http.Cookie;
import io.vertx.core.http.HttpServerRequest;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.BadRequestException;
import jakarta.ws.rs.WebApplicationException;
import org.apache.commons.lang3.NotImplementedException;
import org.apache.commons.lang3.Strings;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@ApplicationScoped
public class OidcStrategy
{
private static final String AUTH_HEADER = "Authorization";
@Inject
SessionCache sessionCache;
public List<Map.Entry<String, String>> filter(HttpServerRequest request, List<Map.Entry<String, String>> input) throws TokenNotFoundException, SessionNotFoundException
{
Optional<String> tokenOptional = getAccessToken(request);
if (!hasAuthHeader(input) && tokenOptional.isPresent())
{
input.add(Map.entry(AUTH_HEADER, String.format("Bearer %s", tokenOptional.get())));
}
return input;
}
private Optional<String> getAccessToken(HttpServerRequest request) throws TokenNotFoundException
{
Set<Cookie> sessions = request.cookies("session");
if (sessions.size() == 1)
{
String session = sessions.iterator().next().getValue();
return Optional.of(sessionCache.get(session));
}
if (sessions.isEmpty())
{
return Optional.empty();
}
throw new BadRequestException();
}
private boolean hasAuthHeader(List<Map.Entry<String, String>> input)
{
for (Map.Entry<String, String> header : input)
{
if (Strings.CI.equals(AUTH_HEADER, header.getKey()))
{
return true;
}
}
return false;
}
}
@@ -1,11 +1,12 @@
package dev.dinauer.oidcproxy.session; package dev.dinauer.oidcproxy.session;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException; import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import io.quarkus.narayana.jta.QuarkusTransaction; import io.quarkus.narayana.jta.QuarkusTransaction;
import io.quarkus.runtime.Startup; import io.quarkus.runtime.Startup;
import jakarta.enterprise.context.ApplicationScoped; import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.context.control.ActivateRequestContext; import jakarta.enterprise.context.control.ActivateRequestContext;
import jakarta.inject.Inject; import jakarta.inject.Inject;
import org.apache.commons.lang3.StringUtils;
import org.jboss.logging.Logger; import org.jboss.logging.Logger;
import java.security.MessageDigest; import java.security.MessageDigest;
@@ -31,7 +32,7 @@ public class SessionCache
return sessionId; return sessionId;
} }
public String get(String sessionId) throws TokenNotFoundException public String get(String sessionId) throws ProxyAuthenticationFailedException
{ {
String sessionHash = toHash(sessionId); String sessionHash = toHash(sessionId);
Optional<String> token = getFromCache(sessionHash); Optional<String> token = getFromCache(sessionHash);
@@ -46,9 +47,12 @@ public class SessionCache
public void remove(String sessionId) public void remove(String sessionId)
{ {
String sessionHash = toHash(sessionId); if (!StringUtils.isBlank(sessionId))
tokens.remove(sessionHash); {
sessionService.remove(sessionHash); String sessionHash = toHash(sessionId);
tokens.remove(sessionHash);
sessionService.remove(sessionHash);
}
} }
public Optional<String> getFromCache(String sessionHash) public Optional<String> getFromCache(String sessionHash)
@@ -3,7 +3,7 @@ package dev.dinauer.oidcproxy.session;
import dev.dinauer.oidcproxy.JwtUtils; import dev.dinauer.oidcproxy.JwtUtils;
import dev.dinauer.oidcproxy.callback.OidcClient; import dev.dinauer.oidcproxy.callback.OidcClient;
import dev.dinauer.oidcproxy.callback.model.TokenResponse; import dev.dinauer.oidcproxy.callback.model.TokenResponse;
import dev.dinauer.oidcproxy.proxy.exception.TokenNotFoundException; import dev.dinauer.oidcproxy.proxy.exception.ProxyAuthenticationFailedException;
import io.quarkus.security.UnauthorizedException; import io.quarkus.security.UnauthorizedException;
import io.smallrye.jwt.auth.principal.DefaultJWTParser; import io.smallrye.jwt.auth.principal.DefaultJWTParser;
import jakarta.enterprise.context.ApplicationScoped; import jakarta.enterprise.context.ApplicationScoped;
@@ -49,7 +49,7 @@ public class SessionService
} }
@Transactional @Transactional
public AccessToken provide(String sessionHash) throws TokenNotFoundException public AccessToken provide(String sessionHash) throws ProxyAuthenticationFailedException
{ {
AccessTokenEntity dbToken = accessTokenRepository.findById(sessionHash); AccessTokenEntity dbToken = accessTokenRepository.findById(sessionHash);
if (isValid(dbToken)) if (isValid(dbToken))
@@ -74,11 +74,11 @@ public class SessionService
} }
catch (Exception e) catch (Exception e)
{ {
throw new TokenNotFoundException(); throw new ProxyAuthenticationFailedException();
} }
} }
throw new TokenNotFoundException(); throw new ProxyAuthenticationFailedException();
} }
@Transactional @Transactional
@@ -2,7 +2,7 @@ package dev.dinauer.oidcproxy.startup;
import java.util.List; import java.util.List;
public record ProxyRoute(String path, String target, String strategy) public record ProxyRoute(String path, String target, boolean dropMatch)
{ {
public String path() public String path()
{ {
@@ -37,17 +37,14 @@ public class RouteService
List<ProxyRoute> result = new LinkedList<>(); List<ProxyRoute> result = new LinkedList<>();
for (ConfigRoute route : rules.routes()) for (ConfigRoute route : rules.routes())
{ {
if (StringUtils.isBlank(route.strategy())) boolean dropMatch = Boolean.TRUE.equals(route.dropMatch());
{
throw new IllegalArgumentException();
}
if (StringUtils.isBlank(rules.root())) if (StringUtils.isBlank(rules.root()))
{ {
result.add(new ProxyRoute(route.path(), route.target(), route.strategy())); result.add(new ProxyRoute(route.path(), route.target(), dropMatch));
} }
else else
{ {
result.add(new ProxyRoute(StringUtils.join(rules.root(), route.path()), route.target(), route.strategy())); result.add(new ProxyRoute(StringUtils.join(rules.root(), route.path()), route.target(), dropMatch));
} }
} }
for (ProxyRoute route : result) for (ProxyRoute route : result)
@@ -1,11 +1,11 @@
package dev.dinauer.oidcproxy.startup.model; package dev.dinauer.oidcproxy.startup.model;
import com.fasterxml.jackson.annotation.JsonProperty;
import dev.dinauer.oidcproxy.startup.PathConverter; import dev.dinauer.oidcproxy.startup.PathConverter;
import org.apache.commons.lang3.StringUtils;
import java.util.List; import java.util.List;
public record ConfigRoute(String path, String target, String strategy) public record ConfigRoute(String path, String target, @JsonProperty("drop-match") Boolean dropMatch)
{ {
public List<String> segments() public List<String> segments()
{ {
+1 -1
View File
@@ -1,4 +1,4 @@
routes: routes:
- path: / - path: /
target: http://localhost:8081 target: http://localhost:8081
strategy: OIDC drop-match: true