Light, fluffy, and always free - The AWS Local Emulator alternative
fix(elbv2): tunnel WebSocket upgrades to instance and ip targets (#4517)
Abhigyae1cc7439f61f
diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.javaindex 6c9e532e57..04767cb5ba 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java@@ -19,10 +19,13 @@ import io.vertx.core.Vertx;import io.vertx.core.buffer.Buffer;import io.vertx.core.http.HttpClient;import io.vertx.core.http.HttpClientOptions;+import io.vertx.core.http.HttpMethod;import io.vertx.core.http.HttpServer;import io.vertx.core.http.HttpServerOptions;import io.vertx.core.http.HttpServerRequest;+import io.vertx.core.http.HttpVersion;import io.vertx.core.http.RequestOptions;+import io.vertx.core.net.NetSocket;import jakarta.annotation.PostConstruct;import jakarta.annotation.PreDestroy;import jakarta.enterprise.context.ApplicationScoped;@@ -40,6 +43,7 @@ import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.atomic.AtomicBoolean;import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicLong;import java.util.concurrent.atomic.AtomicReference;import java.util.regex.Pattern;import java.util.stream.Collectors;@@ -53,6 +57,8 @@ public class ElbV2DataPlane {"connection", "keep-alive", "transfer-encoding", "upgrade", "te", "trailers", "proxy-authorization", "proxy-authenticate");private static final String PRESERVE_HOST_HEADER_ATTRIBUTE = "routing.http.preserve_host_header.enabled";+ private static final String IDLE_TIMEOUT_ATTRIBUTE = "idle_timeout.timeout_seconds";+ private static final long DEFAULT_IDLE_TIMEOUT_SECONDS = 60;private static final int MAX_LAMBDA_BODY_BYTES = 1024 * 1024;@Inject@@ -432,6 +438,10 @@ public class ElbV2DataPlane {}if ("lambda".equals(tg.getTargetType())) {+ if (isWebSocketUpgrade(req)) {+ req.response().setStatusCode(400).end("WebSockets are not supported for Lambda targets");+ return;+ }List<TargetDescription> targets = tg.getTargets();if (targets.isEmpty()) {req.response().setStatusCode(503).end("No Lambda targets registered");@@ -455,19 +465,39 @@ public class ElbV2DataPlane {int idx = Math.abs(counter.getAndIncrement() % candidates.size());TargetDescription target = candidates.get(idx);int targetPort = ElbV2HealthChecker.effectivePort(target, tg);- proxyRequest(req, ElbV2TargetResolver.resolveHost(ec2Service, tg, target), targetPort,- preserveHostHeader(listenerArn, region));+ String host = ElbV2TargetResolver.resolveHost(ec2Service, tg, target);+ boolean preserveHostHeader = Boolean.parseBoolean(+ loadBalancerAttribute(listenerArn, region, PRESERVE_HOST_HEADER_ATTRIBUTE));+ if (isWebSocketUpgrade(req)) {+ proxyUpgrade(req, host, targetPort, preserveHostHeader, idleTimeoutMillis(listenerArn, region));+ return;+ }+ proxyRequest(req, host, targetPort, preserveHostHeader);}- private boolean preserveHostHeader(String listenerArn, String region) {+ private String loadBalancerAttribute(String listenerArn, String region, String key) {ListenerBinding binding = listenerBindings.get(listenerArn);if (binding == null) {- return false;+ return null;}LoadBalancer loadBalancer = elbV2Service.getLoadBalancer(region, binding.loadBalancerArn());- return loadBalancer != null- && loadBalancer.getAttributes() != null- && Boolean.parseBoolean(loadBalancer.getAttributes().get(PRESERVE_HOST_HEADER_ATTRIBUTE));+ if (loadBalancer == null || loadBalancer.getAttributes() == null) {+ return null;+ }+ return loadBalancer.getAttributes().get(key);+ }++ private long idleTimeoutMillis(String listenerArn, String region) {+ String configured = loadBalancerAttribute(listenerArn, region, IDLE_TIMEOUT_ATTRIBUTE);+ long seconds = DEFAULT_IDLE_TIMEOUT_SECONDS;+ if (configured != null) {+ try {+ seconds = Long.parseLong(configured.trim());+ } catch (NumberFormatException e) {+ LOG.debugv("Ignoring non-numeric {0} value {1}", IDLE_TIMEOUT_ATTRIBUTE, configured);+ }+ }+ return Math.max(1, seconds) * 1000;}private void invokeLambdaTarget(io.vertx.core.http.HttpServerRequest req, String functionArn, String region) {@@ -698,7 +728,7 @@ public class ElbV2DataPlane {}});if (!preserveHostHeader) {- clientReq.putHeader("Host", host + ":" + port);+ clientReq.putHeader("Host", ElbV2TargetResolver.hostHeader(host, port));}AtomicBoolean responseStarted = new AtomicBoolean();AtomicBoolean requestFailed = new AtomicBoolean();@@ -745,6 +775,165 @@ public class ElbV2DataPlane {});}+ /**+ * An ALB forwards a WebSocket handshake to an instance or ip target with its upgrade headers+ * intact, which an ordinary proxied request cannot do: {@code Connection} and {@code Upgrade}+ * are hop-by-hop and are stripped. AWS only tunnels WebSocket upgrades, over HTTP/1.1.+ */+ static boolean isWebSocketUpgrade(HttpServerRequest req) {+ if (req.version() != HttpVersion.HTTP_1_1 || req.method() != HttpMethod.GET) {+ return false;+ }+ if (!"websocket".equalsIgnoreCase(req.getHeader("Upgrade"))) {+ return false;+ }+ for (String connection : req.headers().getAll("Connection")) {+ for (String token : connection.split(",")) {+ if ("upgrade".equalsIgnoreCase(token.trim())) {+ return true;+ }+ }+ }+ return false;+ }++ private void proxyUpgrade(HttpServerRequest req, String host, int port, boolean preserveHostHeader,+ long idleTimeoutMillis) {+ req.pause();+ if (ElbV2TargetResolver.isIpLiteral(host)) {+ try {+ proxyUpgradeTo(req, ElbV2TargetResolver.resolveCheckedAddress(host), host, port,+ preserveHostHeader, idleTimeoutMillis);+ } catch (IOException e) {+ rejectTarget(req, host, e);+ }+ return;+ }+ vertx.<String>executeBlocking(() -> ElbV2TargetResolver.resolveCheckedAddress(host))+ .onSuccess(address -> proxyUpgradeTo(req, address, host, port, preserveHostHeader,+ idleTimeoutMillis))+ .onFailure(err -> rejectTarget(req, host, err));+ }++ /**+ * Sends the handshake to the target and, once it answers {@code 101 Switching Protocols},+ * relays that answer and joins the two connections into a byte tunnel. Any other answer means+ * the target refused the upgrade and is relayed as an ordinary response.+ */+ private void proxyUpgradeTo(HttpServerRequest req, String address, String host, int port,+ boolean preserveHostHeader, long idleTimeoutMillis) {+ RequestOptions opts = new RequestOptions()+ .setHost(address)+ .setPort(port)+ .setURI(req.uri())+ .setMethod(req.method());+ proxyClient.request(opts)+ .onSuccess(clientReq -> {+ req.headers().forEach(entry -> {+ if (!HOP_BY_HOP_HEADERS.contains(entry.getKey().toLowerCase())) {+ clientReq.putHeader(entry.getKey(), entry.getValue());+ }+ });+ clientReq.putHeader("Connection", "Upgrade");+ clientReq.putHeader("Upgrade", req.getHeader("Upgrade"));+ if (!preserveHostHeader) {+ clientReq.putHeader("Host", ElbV2TargetResolver.hostHeader(host, port));+ }+ clientReq.connect()+ .onSuccess(resp -> {+ req.response().setStatusCode(resp.statusCode());+ resp.headers().forEach(entry -> {+ if (!HOP_BY_HOP_HEADERS.contains(entry.getKey().toLowerCase())) {+ req.response().putHeader(entry.getKey(), entry.getValue());+ }+ });+ if (resp.statusCode() != 101) {+ req.resume();+ if (resp.getHeader("Content-Length") == null) {+ req.response().setChunked(true);+ }+ resp.pipeTo(req.response());+ return;+ }+ req.response().putHeader("Connection", "Upgrade");+ req.response().putHeader("Upgrade", resp.getHeader("Upgrade"));+ NetSocket targetSocket = resp.netSocket();+ req.toNetSocket()+ .onSuccess(clientSocket ->+ tunnel(clientSocket, targetSocket, idleTimeoutMillis))+ .onFailure(err -> {+ LOG.debugv("WebSocket upgrade to {0}:{1} lost the client: {2}",+ host, String.valueOf(port), err.getMessage());+ targetSocket.close();+ });+ })+ .onFailure(err -> {+ LOG.debugv("WebSocket upgrade to {0}:{1} failed: {2}",+ host, String.valueOf(port), err.getMessage());+ req.resume();+ if (req.response().headWritten()) {+ req.response().close();+ } else {+ req.response().setStatusCode(502).end("Bad gateway");+ }+ });+ })+ .onFailure(err -> {+ req.resume();+ req.response().setStatusCode(503).end("Service unavailable");+ });+ }++ /**+ * Relays bytes both ways until either side closes or no data crosses the tunnel in either+ * direction for the load balancer's {@code idle_timeout.timeout_seconds}, as an ALB does.+ */+ private void tunnel(NetSocket client, NetSocket target, long idleTimeoutMillis) {+ AtomicLong lastActivity = new AtomicLong(System.nanoTime());+ AtomicLong timerId = new AtomicLong(-1);+ AtomicBoolean closed = new AtomicBoolean();+ Runnable close = () -> {+ if (closed.compareAndSet(false, true)) {+ vertx.cancelTimer(timerId.get());+ client.close();+ target.close();+ }+ };+ relay(client, target, lastActivity, close);+ relay(target, client, lastActivity, close);+ scheduleIdleCheck(idleTimeoutMillis, idleTimeoutMillis, lastActivity, timerId, closed, close);+ }++ private void scheduleIdleCheck(long delayMillis, long idleTimeoutMillis, AtomicLong lastActivity,+ AtomicLong timerId, AtomicBoolean closed, Runnable close) {+ if (closed.get()) {+ return;+ }+ timerId.set(vertx.setTimer(delayMillis, ignored -> {+ long idleMillis = (System.nanoTime() - lastActivity.get()) / 1_000_000;+ if (idleMillis >= idleTimeoutMillis) {+ close.run();+ } else {+ scheduleIdleCheck(idleTimeoutMillis - idleMillis, idleTimeoutMillis, lastActivity, timerId,+ closed, close);+ }+ }));+ }++ private static void relay(NetSocket source, NetSocket destination, AtomicLong lastActivity, Runnable close) {+ source.handler(buffer -> {+ lastActivity.set(System.nanoTime());+ destination.write(buffer);+ if (destination.writeQueueFull()) {+ source.pause();+ destination.drainHandler(ignored -> source.resume());+ }+ });+ source.endHandler(ignored -> close.run());+ source.closeHandler(ignored -> close.run());+ source.exceptionHandler(err -> close.run());+ }+private void executeRedirect(io.vertx.core.http.HttpServerRequest req, Action action) {String reqHost = req.host();String reqPort = "";diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.javaindex 55efa163ba..6563c4aec7 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolver.java@@ -47,6 +47,14 @@ final class ElbV2TargetResolver {return addresses[0].getHostAddress();}+ /** The {@code Host} header value for a target, bracketing an IPv6 literal as RFC 3986 requires. */+ static String hostHeader(String host, int port) {+ if (host.indexOf(':') >= 0 && !host.startsWith("[")) {+ return "[" + host + "]:" + port;+ }+ return host + ":" + port;+ }+static boolean isIpLiteral(String host) {return host != null && (host.contains(":") || host.matches("[0-9.]+"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.javaindex 74ffdb6b47..8c27c86f81 100644--- a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2TargetResolverTest.java@@ -74,4 +74,12 @@ class ElbV2TargetResolverTest {assertTrue(ex.getMessage().contains("link-local or metadata address"), ex.getMessage());}}++ @Test+ void hostHeaderBracketsIpv6Literals() {+ assertEquals("[2001:db8::1]:8080", ElbV2TargetResolver.hostHeader("2001:db8::1", 8080));+ assertEquals("[::1]:80", ElbV2TargetResolver.hostHeader("[::1]", 80));+ assertEquals("10.0.0.5:8080", ElbV2TargetResolver.hostHeader("10.0.0.5", 8080));+ assertEquals("backend.internal:443", ElbV2TargetResolver.hostHeader("backend.internal", 443));+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2WebSocketIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2WebSocketIntegrationTest.javanew file mode 100644index 0000000000..9a3c9c1f90--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2WebSocketIntegrationTest.java@@ -0,0 +1,373 @@+package io.github.hectorvent.floci.services.elbv2;++import io.github.hectorvent.floci.services.ec2.Ec2Service;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.testing.RealElbV2DataPlaneProfile;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import io.quarkus.test.junit.mockito.InjectSpy;+import io.vertx.core.Vertx;+import io.vertx.core.http.HttpClient;+import io.vertx.core.http.HttpServer;+import io.vertx.core.http.UpgradeRejectedException;+import io.vertx.core.http.WebSocket;+import io.vertx.core.http.WebSocketConnectOptions;+import jakarta.inject.Inject;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.time.Duration;+import java.util.concurrent.CompletableFuture;+import java.util.concurrent.ExecutionException;+import java.util.concurrent.TimeUnit;++import static io.restassured.RestAssured.given;+import static org.awaitility.Awaitility.await;+import static org.hamcrest.Matchers.anyOf;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertInstanceOf;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doReturn;++@QuarkusTest+@TestProfile(RealElbV2DataPlaneProfile.class)+class ElbV2WebSocketIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260927/us-east-1/elasticloadbalancing/aws4_request";+ private static final int LISTENER_PORT = 7795;+ private static final String INSTANCE_ID = "i-0websocket0000001";++ @Inject+ Vertx vertx;++ @InjectSpy+ Ec2Service ec2Service;++ private HttpServer backend;+ private HttpClient client;+ private String loadBalancerArn;+ private String targetGroupArn;+ private String listenerArn;++ @BeforeEach+ void startBackend() throws Exception {+ backend = vertx.createHttpServer()+ .requestHandler(request -> {+ if (!"websocket".equalsIgnoreCase(request.getHeader("Upgrade"))) {+ request.response().setStatusCode(400).end("not an upgrade");+ } else if (!request.path().startsWith("/socket.io/")) {+ request.response().setStatusCode(404).end();+ } else {+ String query = request.query();+ request.toWebSocket().onSuccess(socket -> socket.textMessageHandler(+ text -> socket.writeTextMessage(query + ":" + text)));+ }+ })+ .listen(0, "127.0.0.1")+ .toCompletionStage()+ .toCompletableFuture()+ .get(2, TimeUnit.SECONDS);+ client = vertx.createHttpClient();+ loadBalancerArn = createLoadBalancer();+ targetGroupArn = createTargetGroup("websocket-tg", "ip", backend.actualPort());+ registerTarget(targetGroupArn, "127.0.0.1", backend.actualPort());+ listenerArn = createListener(loadBalancerArn, targetGroupArn);+ await().atMost(Duration.ofSeconds(3)).untilAsserted(() -> given()+ .baseUri("http://127.0.0.1")+ .port(LISTENER_PORT)+ .when()+ .get("/")+ .then()+ .statusCode(400));+ }++ @AfterEach+ void stopBackend() throws Exception {+ deleteListener(listenerArn);+ deleteTargetGroup(targetGroupArn);+ deleteLoadBalancer(loadBalancerArn);+ client.close().toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ backend.close().toCompletionStage().toCompletableFuture().get(2, TimeUnit.SECONDS);+ }++ @Test+ void tunnelsWebSocketUpgradeToIpTarget() throws Exception {+ WebSocket socket = connect("/socket.io/?EIO=4&transport=websocket");+ try {+ assertEquals("EIO=4&transport=websocket:hello", exchange(socket, "hello"));+ assertEquals("EIO=4&transport=websocket:again", exchange(socket, "again"));+ } finally {+ socket.close();+ }+ }++ @Test+ void tunnelsWebSocketUpgradeToInstanceTarget() throws Exception {+ Instance instance = new Instance();+ instance.setInstanceId(INSTANCE_ID);+ instance.setContainerBridgeIp("127.0.0.1");+ doReturn(instance).when(ec2Service).findInstanceById(anyString(), eq(INSTANCE_ID));+ String instanceTargetGroupArn = createTargetGroup("websocket-instance-tg", "instance", backend.actualPort());+ try {+ registerTarget(instanceTargetGroupArn, INSTANCE_ID, backend.actualPort());+ forwardDefaultActionTo(listenerArn, instanceTargetGroupArn);++ WebSocket socket = connect("/socket.io/?transport=websocket");+ try {+ assertEquals("transport=websocket:hello", exchange(socket, "hello"));+ } finally {+ socket.close();+ }+ } finally {+ deleteListener(listenerArn);+ listenerArn = null;+ deleteTargetGroup(instanceTargetGroupArn);+ }+ }++ @Test+ void relaysTargetRejectionOfUpgrade() {+ ExecutionException failure = assertThrows(ExecutionException.class,+ () -> connect("/elsewhere/?transport=websocket"));++ UpgradeRejectedException rejected = assertInstanceOf(UpgradeRejectedException.class, failure.getCause());+ assertEquals(404, rejected.getStatus());+ }++ @Test+ void plainRequestStillReachesTargetWithoutUpgrade() {+ given()+ .baseUri("http://127.0.0.1")+ .port(LISTENER_PORT)+ .when()+ .get("/socket.io/?transport=polling")+ .then()+ .statusCode(400)+ .body(equalTo("not an upgrade"));+ }++ @Test+ void closesTunnelAfterLoadBalancerIdleTimeout() throws Exception {+ setIdleTimeout(loadBalancerArn, 1);+ WebSocket socket = connect("/socket.io/?transport=websocket");+ CompletableFuture<Void> closed = new CompletableFuture<>();+ socket.closeHandler(ignored -> closed.complete(null));++ assertEquals("transport=websocket:ping", exchange(socket, "ping"));++ closed.get(5, TimeUnit.SECONDS);+ }++ @Test+ void rejectsUpgradeToLambdaTargetWith400() throws Exception {+ String functionArn = createFunction("alb-websocket-fn");+ String lambdaTargetGroupArn = null;+ try {+ lambdaTargetGroupArn = createLambdaTargetGroup(functionArn);+ forwardDefaultActionTo(listenerArn, lambdaTargetGroupArn);++ ExecutionException failure = assertThrows(ExecutionException.class,+ () -> connect("/socket.io/?transport=websocket"));++ UpgradeRejectedException rejected = assertInstanceOf(UpgradeRejectedException.class, failure.getCause());+ assertEquals(400, rejected.getStatus());+ } finally {+ deleteListener(listenerArn);+ listenerArn = null;+ deleteTargetGroup(lambdaTargetGroupArn);+ given().when().delete("/2015-03-31/functions/alb-websocket-fn").then()+ .statusCode(anyOf(equalTo(200), equalTo(204)));+ }+ }++ private static String createFunction(String name) {+ return given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "%s",+ "Runtime": "nodejs20.x",+ "Role": "arn:aws:iam::000000000000:role/lambda-role",+ "Handler": "index.handler"+ }+ """.formatted(name))+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(201)+ .extract()+ .path("FunctionArn");+ }++ private static String createLambdaTargetGroup(String functionArn) {+ String targetGroupArn = given()+ .formParam("Action", "CreateTargetGroup")+ .formParam("Name", "websocket-lambda-tg")+ .formParam("TargetType", "lambda")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract()+ .path("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetGroupArn");+ given()+ .formParam("Action", "RegisterTargets")+ .formParam("TargetGroupArn", targetGroupArn)+ .formParam("Targets.member.1.Id", functionArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ return targetGroupArn;+ }++ private static void forwardDefaultActionTo(String listenerArn, String targetGroupArn) {+ given()+ .formParam("Action", "ModifyListener")+ .formParam("ListenerArn", listenerArn)+ .formParam("DefaultActions.member.1.Type", "forward")+ .formParam("DefaultActions.member.1.TargetGroupArn", targetGroupArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private WebSocket connect(String uri) throws Exception {+ return client.webSocket(new WebSocketConnectOptions()+ .setHost("127.0.0.1")+ .setPort(LISTENER_PORT)+ .setURI(uri))+ .toCompletionStage()+ .toCompletableFuture()+ .get(5, TimeUnit.SECONDS);+ }++ private static String exchange(WebSocket socket, String text) throws Exception {+ CompletableFuture<String> reply = new CompletableFuture<>();+ socket.textMessageHandler(reply::complete);+ socket.writeTextMessage(text);+ return reply.get(5, TimeUnit.SECONDS);+ }++ private static String createLoadBalancer() {+ return given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Name", "websocket-lb")+ .formParam("Type", "application")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract()+ .path("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.LoadBalancerArn");+ }++ private static String createTargetGroup(String name, String targetType, int backendPort) {+ return given()+ .formParam("Action", "CreateTargetGroup")+ .formParam("Name", name)+ .formParam("Protocol", "HTTP")+ .formParam("Port", backendPort)+ .formParam("TargetType", targetType)+ .formParam("HealthCheckEnabled", "false")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract()+ .path("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetGroupArn");+ }++ private static void registerTarget(String targetGroupArn, String targetId, int backendPort) {+ given()+ .formParam("Action", "RegisterTargets")+ .formParam("TargetGroupArn", targetGroupArn)+ .formParam("Targets.member.1.Id", targetId)+ .formParam("Targets.member.1.Port", backendPort)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static String createListener(String loadBalancerArn, String targetGroupArn) {+ return given()+ .formParam("Action", "CreateListener")+ .formParam("LoadBalancerArn", loadBalancerArn)+ .formParam("Protocol", "HTTP")+ .formParam("Port", LISTENER_PORT)+ .formParam("DefaultActions.member.1.Type", "forward")+ .formParam("DefaultActions.member.1.TargetGroupArn", targetGroupArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract()+ .path("CreateListenerResponse.CreateListenerResult.Listeners.member.ListenerArn");+ }++ private static void setIdleTimeout(String loadBalancerArn, int seconds) {+ given()+ .formParam("Action", "ModifyLoadBalancerAttributes")+ .formParam("LoadBalancerArn", loadBalancerArn)+ .formParam("Attributes.member.1.Key", "idle_timeout.timeout_seconds")+ .formParam("Attributes.member.1.Value", String.valueOf(seconds))+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static void deleteListener(String listenerArn) {+ if (listenerArn != null) {+ given()+ .formParam("Action", "DeleteListener")+ .formParam("ListenerArn", listenerArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(anyOf(equalTo(200), equalTo(204)));+ }+ }++ private static void deleteTargetGroup(String targetGroupArn) {+ if (targetGroupArn != null) {+ given()+ .formParam("Action", "DeleteTargetGroup")+ .formParam("TargetGroupArn", targetGroupArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(anyOf(equalTo(200), equalTo(204)));+ }+ }++ private static void deleteLoadBalancer(String loadBalancerArn) {+ if (loadBalancerArn != null) {+ given()+ .formParam("Action", "DeleteLoadBalancer")+ .formParam("LoadBalancerArn", loadBalancerArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(anyOf(equalTo(200), equalTo(204)));+ }+ }+}