Make byte buffer size configurable. Add configurable whitelist of proxy targets. Factor out common IO code. Switch to using Vert.x server. Add support for HTTPS. Handle exceptions seen when connection dies between client and server. Refactored domain proxy in general for consistency.

Author: tecarter94

java-components/domainproxy/.dockerignore renamed to java-components/domain-proxy/.dockerignore

@@ -0,0 +1,4 @@
+FROM quay.io/redhat-appstudio/buildah:v1.35.4@sha256:3d3575bb7d0df64abcf1f22f06e82101a945d03317db1f3caac12814f796d01c
+RUN dnf install -y iproute
+COPY client/target/domain-proxy-client-999-SNAPSHOT-runner /app/domain-proxy-client-runner
+COPY server/target/domain-proxy-server-999-SNAPSHOT-runner /app/domain-proxy-server-runner

java-components/domain-proxy/Dockerfile

@@ -4,10 +4,10 @@
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>io.github.redhat-appstudio.jvmbuild</groupId>
-        <artifactId>domainproxy-parent</artifactId>
+        <artifactId>domain-proxy-parent</artifactId>
         <version>999-SNAPSHOT</version>
     </parent>
-    <artifactId>domainproxy-client</artifactId>
+    <artifactId>domain-proxy-client</artifactId>
 
     <dependencies>
         <dependency>
@@ -24,6 +24,10 @@
             <artifactId>rest-assured</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.github.redhat-appstudio.jvmbuild</groupId>
+            <artifactId>domain-proxy-common</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

java-components/domainproxy/client/pom.xml renamed to java-components/domain-proxy/client/pom.xml

@@ -0,0 +1,57 @@
+package com.redhat.hacbs.domainproxy.client;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.UnixDomainSocketAddress;
+import java.nio.channels.SocketChannel;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+
+import com.redhat.hacbs.domainproxy.common.CommonIOUtil;
+
+import io.quarkus.logging.Log;
+import io.quarkus.runtime.Quarkus;
+import io.quarkus.runtime.Startup;
+
+@Startup
+@Singleton
+public class DomainProxyClient {
+
+    @Inject
+    @ConfigProperty(name = "client-domain-socket")
+    String domainSocket;
+
+    @Inject
+    @ConfigProperty(name = "client-http-port")
+    int clientHttpPort;
+
+    @Inject
+    @ConfigProperty(name = "byte-buffer-size")
+    int byteBufferSize;
+
+    @PostConstruct
+    public void start() {
+        Log.info("Starting domain proxy client...");
+        new Thread(() -> {
+            try (final ServerSocket serverSocket = new ServerSocket(clientHttpPort)) {
+                while (true) {
+                    final Socket socket = serverSocket.accept();
+                    final UnixDomainSocketAddress address = UnixDomainSocketAddress.of(domainSocket);
+                    final SocketChannel channel = SocketChannel.open(address);
+                    // write from socket to channel
+                    CommonIOUtil.createSocketToChannelWriter(byteBufferSize, socket, channel).start();
+                    // write from channel to socket
+                    CommonIOUtil.createChannelToSocketWriter(byteBufferSize, channel, socket).start();
+                }
+            } catch (final IOException e) {
+                Log.errorf(e, "Error initialising domain proxy client");
+            }
+            Quarkus.asyncExit();
+        }).start();
+    }
+}

java-components/domain-proxy/client/src/main/java/com/redhat/hacbs/domainproxy/client/DomainProxyClient.java

@@ -0,0 +1,3 @@
+client-domain-socket=${DOMAIN_SOCKET:/tmp/domainserver}
+client-http-port=8080
+byte-buffer-size=${BYTE_BUFFER_SIZE:1024}

java-components/domain-proxy/client/src/main/resources/application.properties

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>io.github.redhat-appstudio.jvmbuild</groupId>
+        <artifactId>domain-proxy-parent</artifactId>
+        <version>999-SNAPSHOT</version>
+    </parent>
+    <artifactId>domain-proxy-common</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jboss.logging</groupId>
+            <artifactId>jboss-logging</artifactId>
+        </dependency>
+    </dependencies>
+</project>

java-components/domain-proxy/common/pom.xml

@@ -0,0 +1,84 @@
+package com.redhat.hacbs.domainproxy.common;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.SocketException;
+import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousCloseException;
+import java.nio.channels.SocketChannel;
+
+import org.jboss.logging.Logger;
+
+public final class CommonIOUtil {
+
+    private static final Logger LOG = Logger.getLogger(CommonIOUtil.class);
+
+    public static Thread createSocketToChannelWriter(final int byteBufferSize, final Socket socket,
+            final SocketChannel channel) {
+        // write from socket to channel
+        return new Thread(() -> {
+            int r;
+            final byte[] buf = new byte[byteBufferSize];
+            int bytesWritten = 0;
+            LOG.info("Writing from socket to channel");
+            try {
+                while ((r = socket.getInputStream().read(buf)) > 0) {
+                    channel.write(ByteBuffer.wrap(buf, 0, r));
+                    bytesWritten += r;
+                }
+            } catch (final SocketException ignore) {
+                LOG.info("Socket closed");
+            } catch (final IOException e) {
+                LOG.errorf(e, "Error writing from socket to channel");
+            } finally {
+                try {
+                    channel.close();
+                } catch (final Exception e) {
+                    LOG.errorf(e, "Error closing channel");
+                }
+                try {
+                    socket.close();
+                } catch (final IOException e) {
+                    LOG.errorf(e, "Error closing socket");
+                }
+            }
+            LOG.infof("Wrote %d bytes from socket to channel", bytesWritten);
+        });
+    }
+
+    public static Thread createChannelToSocketWriter(final int byteBufferSize, final SocketChannel channel,
+            final Socket socket) {
+        // write from channel to socket
+        return new Thread(() -> {
+            int r;
+            final ByteBuffer buf = ByteBuffer.allocate(byteBufferSize);
+            buf.clear();
+            int bytesWritten = 0;
+            LOG.info("Writing from channel to socket");
+            try {
+                while ((r = channel.read(buf)) > 0) {
+                    buf.flip();
+                    socket.getOutputStream().write(buf.array(), buf.arrayOffset(), buf.remaining());
+                    buf.clear();
+                    bytesWritten += r;
+                }
+            } catch (final AsynchronousCloseException ignore) {
+                LOG.info("Channel closed");
+            } catch (final Exception e) {
+                LOG.errorf(e, "Error writing from channel to socket");
+            } finally {
+                try {
+                    channel.close();
+                } catch (final IOException e) {
+                    LOG.errorf(e, "Error closing channel");
+                }
+                try {
+                    socket.close();
+                } catch (final IOException e) {
+                    LOG.errorf(e, "Error closing socket");
+                }
+            }
+            LOG.infof("Wrote %d bytes from channel to socket", bytesWritten);
+        });
+    }
+}

java-components/domain-proxy/common/src/main/java/com/redhat/hacbs/domainproxy/common/CommonIOUtil.java

@@ -7,7 +7,7 @@
         <artifactId>jvm-build-service-parent</artifactId>
         <version>999-SNAPSHOT</version>
     </parent>
-    <artifactId>domainproxy-parent</artifactId>
+    <artifactId>domain-proxy-parent</artifactId>
     <packaging>pom</packaging>
     <properties>
         <skipITs>true</skipITs>
@@ -16,8 +16,19 @@
     <modules>
         <module>server</module>
         <module>client</module>
+        <module>common</module>
     </modules>
 
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>io.github.redhat-appstudio.jvmbuild</groupId>
+                <artifactId>domain-proxy-common</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
     <profiles>
         <profile>
             <id>native</id>

java-components/domainproxy/pom.xml renamed to java-components/domain-proxy/pom.xml

@@ -4,15 +4,15 @@
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>io.github.redhat-appstudio.jvmbuild</groupId>
-        <artifactId>domainproxy-parent</artifactId>
+        <artifactId>domain-proxy-parent</artifactId>
         <version>999-SNAPSHOT</version>
     </parent>
-    <artifactId>domainproxy-server</artifactId>
+    <artifactId>domain-proxy-server</artifactId>
 
     <dependencies>
         <dependency>
             <groupId>io.quarkus</groupId>
-            <artifactId>quarkus-rest</artifactId>
+            <artifactId>quarkus-vertx</artifactId>
         </dependency>
         <dependency>
             <groupId>io.quarkus</groupId>
@@ -30,7 +30,7 @@
         </dependency>
         <dependency>
             <groupId>io.github.redhat-appstudio.jvmbuild</groupId>
-            <artifactId>common-maven</artifactId>
+            <artifactId>domain-proxy-common</artifactId>
         </dependency>
     </dependencies>
 

java-components/domainproxy/server/pom.xml renamed to java-components/domain-proxy/server/pom.xml

@@ -0,0 +1,70 @@
+package com.redhat.hacbs.domainproxy;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.StandardProtocolFamily;
+import java.net.UnixDomainSocketAddress;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import jakarta.annotation.PostConstruct;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+
+import com.redhat.hacbs.domainproxy.common.CommonIOUtil;
+
+import io.quarkus.logging.Log;
+import io.quarkus.runtime.Quarkus;
+import io.quarkus.runtime.Startup;
+
+@Startup
+@Singleton
+public class DomainProxyServer {
+
+    static final String HOST = "localhost";
+
+    @Inject
+    @ConfigProperty(name = "server-domain-socket")
+    String domainSocket;
+
+    @Inject
+    @ConfigProperty(name = "server-http-port")
+    int serverHttpPort;
+
+    @Inject
+    @ConfigProperty(name = "byte-buffer-size")
+    int byteBufferSize;
+
+    @PostConstruct
+    public void start() {
+        Log.info("Starting domain proxy server...");
+        new Thread(() -> {
+            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+                try {
+                    Files.delete(Path.of(domainSocket));
+                } catch (final IOException e) {
+                    Log.errorf(e, "Error deleting domain socket");
+                }
+            }));
+            try (final ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.UNIX)) {
+                final UnixDomainSocketAddress address = UnixDomainSocketAddress.of(domainSocket);
+                serverChannel.bind(address);
+                while (true) {
+                    final SocketChannel channel = serverChannel.accept();
+                    final Socket socket = new Socket(HOST, serverHttpPort);
+                    // write from socket to channel
+                    CommonIOUtil.createSocketToChannelWriter(byteBufferSize, socket, channel).start();
+                    // write from channel to socket
+                    CommonIOUtil.createChannelToSocketWriter(byteBufferSize, channel, socket).start();
+                }
+            } catch (final IOException e) {
+                Log.errorf(e, "Error initialising domain proxy server");
+            }
+            Quarkus.asyncExit();
+        }).start();
+    }
+}