Merge pull request #65 from ignorant05/enhancement/configurable-inbound-message-size

Fix: configurable max message inbound size

Author: rrobetti

documents/configuration/ojp-jdbc-configuration.md

@@ -49,6 +49,12 @@ ojp.connection.pool.maximumPoolSize=20
 ojp.connection.pool.minimumIdle=5
 ojp.connection.pool.idleTimeout=600000
 ```
+#### Default Maximum Inbound Message Size Configuration 
+
+```properties
+# Default Maximum Inbound Message Size Configuration 
+ojp.grpc.maxInboundMessageSize=16777216  
+```
 
 ### How to Use DataSources
 
@@ -332,4 +338,4 @@ The multi-datasource feature is fully backward compatible:
 ## Related Documentation
 
 - **[OJP Server Configuration](ojp-server-configuration.md)** - Server startup options and runtime configuration
-- **[Example Configuration Properties](ojp-server-example.properties)** - Complete example configuration file with all settings
+- **[Example Configuration Properties](ojp-server-example.properties)** - Complete example configuration file with all settings

ojp-grpc-commons/pom.xml

@@ -26,6 +26,22 @@
     </properties>
 
     <dependencies>
+        <!-- JUnit 5 API -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- JUnit 5 Engine for running tests -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency> 
+
         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
         <dependency>
             <groupId>org.slf4j</groupId>
@@ -103,7 +119,17 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.1.2</version>
+                <configuration>
+                    <includes>
+                        <include>**/*Test.java</include>
+                    </includes>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 
-</project>
+</project>

ojp-grpc-commons/src/main/java/org/openjproxy/config/GrpcClientConfig.java

@@ -0,0 +1,63 @@
+package org.openjproxy.config;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Properties;
+
+/**
+ * Configuration class for gRPC client settings.
+ * <p>
+ * Loads values such as maximum inbound message sizes
+ * from a properties file named {@code ojp.properties} located in the classpath.
+ * </p>
+ * <p>
+ * If properties are missing, default values (16MB) are applied.
+ * </p>
+ */
+public class GrpcClientConfig {
+    /** Default message size in bytes (16MB) */
+    private static final String DEFAULT_SIZE = "16777216";
+
+    private int maxInboundMessageSize;
+
+    /**
+     * Constructs a new {@code GrpcClientConfig} using the provided {@link Properties}.
+     * <p>
+     * If expected keys are missing, default values are used.
+     * </p>
+     *
+     * @param props the {@link Properties} object containing configuration values
+     */
+    public GrpcClientConfig(Properties props) {
+        this.maxInboundMessageSize = Integer.parseInt(
+                props.getProperty("ojp.grpc.maxInboundMessageSize", DEFAULT_SIZE));
+    }
+
+    /**
+     * Returns the maximum allowed inbound message size (in bytes).
+     *
+     * @return the max inbound message size
+     */
+    public int getMaxInboundMessageSize() {
+        return this.maxInboundMessageSize;
+    }
+
+    /**
+     * Loads the gRPC client configuration from a {@code ojp.properties} file
+     * located in the classpath.
+     *
+     * @return a new instance of {@code GrpcClientConfig} with loaded values
+     * @throws IOException if the file is not found or cannot be read
+     */
+    public static GrpcClientConfig load() throws IOException {
+        try (InputStream in = GrpcClientConfig.class.getClassLoader().getResourceAsStream("ojp.properties")) {
+            if (in == null) {
+                throw new FileNotFoundException("Could not find ojp.properties in classpath");
+            }
+            Properties props = new Properties();
+            props.load(in);
+            return new GrpcClientConfig(props);
+        }
+    }
+}

ojp-grpc-commons/src/main/java/org/openjproxy/grpc/GrpcChannelFactory.java

@@ -0,0 +1,86 @@
+package org.openjproxy.grpc;
+
+import org.openjproxy.config.GrpcClientConfig;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import java.io.IOException;
+import java.util.Properties;
+/**
+ * Factory class for creating and configuring gRPC {@link ManagedChannel} instances.
+ * 
+ * <p>This class reads configuration from {@link GrpcClientConfig} and provides overloaded methods
+ * to create channels with default or custom settings.</p>
+ * 
+ * <p>By default, it uses a maximum inbound message size of 16MB.</p>
+ */
+public class GrpcChannelFactory {
+    /** Default maximum inbound message size (16MB) */
+    private static int maxInboundMessageSize = 16777216;
+
+    /** gRPC client configuration loaded from properties file */
+    static GrpcClientConfig grpcConfig;
+
+    /**
+     * Constructor that initializes gRPC client configuration.
+     */
+    public GrpcChannelFactory() {
+        initializeGrpcConfig();
+    }
+
+    /**
+     * Initializes the gRPC client configuration from external properties.
+     * 
+     * <p>If loading fails, it falls back to an empty configuration.</p>
+     */
+    public static void initializeGrpcConfig() {
+        try {
+            grpcConfig = GrpcClientConfig.load();
+        } catch (IOException e) {
+            e.printStackTrace();
+            grpcConfig = new GrpcClientConfig(new Properties());
+        }
+
+        maxInboundMessageSize = grpcConfig.getMaxInboundMessageSize();
+    }
+
+    /**
+     * Creates a new {@link ManagedChannel} for the given host and port with specified
+     * inbound message size limits.
+     *
+     * @param host The gRPC server host
+     * @param port The gRPC server port
+     * @param maxInboundSize Maximum allowed inbound message size in bytes
+     * @return A configured {@link ManagedChannel} instance
+     */
+    public static ManagedChannel createChannel(String host, int port, int maxInboundSize) {
+        return ManagedChannelBuilder.forAddress(host, port)
+                .usePlaintext()
+                .maxInboundMessageSize(maxInboundSize)
+                .build();
+    }
+
+    /**
+     * Creates a new {@link ManagedChannel} for the given host and port using default message size limits.
+     *
+     * @param host The gRPC server host
+     * @param port The gRPC server port
+     * @return A configured {@link ManagedChannel} instance
+     */
+    public static ManagedChannel createChannel(String host, int port) {
+        return createChannel(host, port, maxInboundMessageSize);
+    }
+
+    /**
+     * Creates a new {@link ManagedChannel} for the given target string (e.g., "localhost:50051").
+     * Uses default message size limits.
+     *
+     * @param target A target string in the form "host:port"
+     * @return A configured {@link ManagedChannel} instance
+     */
+    public static ManagedChannel createChannel(String target) {
+        return ManagedChannelBuilder.forTarget(target)
+                .usePlaintext()
+                .maxInboundMessageSize(maxInboundMessageSize)
+                .build();
+    }
+}

ojp-grpc-commons/src/main/proto/echo.proto

@@ -0,0 +1,16 @@
+syntax = "proto3";
+package org.openjproxy.grpc;
+option java_multiple_files = true;
+option java_outer_classname = "EchoServiceProto";
+
+service EchoService {
+  rpc Echo (EchoRequest) returns (EchoResponse);
+}
+
+message EchoRequest {
+  string message = 1;
+}
+
+message EchoResponse {
+  string message = 1;
+}

ojp-grpc-commons/src/main/resources/ojp.properties

@@ -0,0 +1,2 @@
+# 16MB is the default max inbound message size 
+ojp.grpc.maxInboundMessageSize=16777216    

ojp-grpc-commons/src/test/java/org/openjproxy/grpc/DummyEchoService.java

@@ -0,0 +1,17 @@
+package org.openjproxy.grpc;
+
+import org.openjproxy.grpc.EchoRequest;
+import org.openjproxy.grpc.EchoResponse;
+import org.openjproxy.grpc.EchoServiceGrpc;
+import io.grpc.stub.StreamObserver;
+
+// Just echoing back the message
+public class DummyEchoService extends EchoServiceGrpc.EchoServiceImplBase {
+	@Override
+	public void echo(EchoRequest request, StreamObserver<EchoResponse> responseObserver) {
+		responseObserver.onNext(EchoResponse.newBuilder()
+				.setMessage(request.getMessage())
+				.build());
+		responseObserver.onCompleted();
+	}
+}

ojp-grpc-commons/src/test/java/org/openjproxy/grpc/GrpcMessageSizeTest.java

@@ -0,0 +1,74 @@
+package org.openjproxy.grpc;
+
+import org.openjproxy.grpc.EchoRequest;
+import org.openjproxy.grpc.EchoResponse;
+import org.openjproxy.grpc.EchoServiceGrpc;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StatusRuntimeException;
+import org.junit.jupiter.api.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class GrpcMessageSizeTest {
+
+	static final int PORT = 5555; // Just a random port
+	static final int SIZE_LIMIT = 16 * 1024 * 1024; // Since 16MB is the default
+	static Server server;
+
+	@BeforeAll
+	static void startServer() throws Exception {
+		server = ServerBuilder.forPort(PORT)
+				.addService(new DummyEchoService())
+				.maxInboundMessageSize(SIZE_LIMIT)
+				.build()
+				.start();
+	}
+
+	@AfterAll
+	static void stopServer() throws Exception {
+		server.shutdownNow();
+	}
+
+	EchoServiceGrpc.EchoServiceBlockingStub getStub(int inboundSize) {
+		ManagedChannel channel = GrpcChannelFactory.createChannel("localhost", PORT, inboundSize);
+		return EchoServiceGrpc.newBlockingStub(channel);
+	}
+
+	String generateMessageOfSize(int sizeInBytes) {
+		return "a".repeat(sizeInBytes);
+	}
+
+	// This should pass
+	@Test
+	void testMessageBelowSizeLimit() {
+		String message = generateMessageOfSize(SIZE_LIMIT - 100); // Just under 16MB
+		EchoServiceGrpc.EchoServiceBlockingStub stub = getStub(SIZE_LIMIT);
+		EchoResponse response = stub.echo(EchoRequest.newBuilder().setMessage(message).build());
+		assertEquals(message, response.getMessage());
+	}
+
+	// This should pass
+	@Test
+	void testMessageAtSizeLimit() {
+		String message = generateMessageOfSize(SIZE_LIMIT - 10); // Exactly 16MB
+		EchoServiceGrpc.EchoServiceBlockingStub stub = getStub(SIZE_LIMIT);
+		EchoResponse response = stub.echo(EchoRequest.newBuilder().setMessage(message).build());
+		assertEquals(message, response.getMessage());
+	}
+
+	// This should fail
+	@Test
+	void testMessageExceedsSizeLimit() {
+		String message = generateMessageOfSize(SIZE_LIMIT + 1); // Just over 16MB
+		EchoServiceGrpc.EchoServiceBlockingStub stub = getStub(SIZE_LIMIT);
+
+		Exception exception = assertThrows(StatusRuntimeException.class, () -> {
+			stub.echo(EchoRequest.newBuilder().setMessage(message).build());
+		});
+
+		System.out.println("Expected exception: " + exception.getMessage());
+		assertTrue(exception.getMessage().contains("RESOURCE_EXHAUSTED"));
+	}
+}

ojp-jdbc-driver/src/main/java/org/openjproxy/grpc/client/StatementServiceGrpcClient.java

@@ -22,6 +22,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.openjproxy.constants.CommonConstants;
 import org.openjproxy.grpc.dto.Parameter;
+import org.openjproxy.grpc.GrpcChannelFactory;
 import org.openjproxy.jdbc.Connection;
 import org.openjproxy.jdbc.LobGrpcIterator;
 
@@ -80,9 +81,7 @@ private void grpcChannelOpenAndStubsInitialized(String url) {
 
             //Once channel is open it remains open and is shared among all requests.
             String target = DNS_PREFIX + host + COLON + port;
-            ManagedChannel channel = ManagedChannelBuilder.forTarget(target)
-                    .usePlaintext()
-                    .build();
+            ManagedChannel channel = GrpcChannelFactory.createChannel(target);
 
             this.statemetServiceBlockingStub = StatementServiceGrpc.newBlockingStub(channel);
             this.statemetServiceStub = StatementServiceGrpc.newStub(channel);

ojp-jdbc-driver/src/test/java/openjproxy/grpc/client/StatementGrpcClient.java

@@ -0,0 +1,33 @@
+package org.openjproxy.grpc.client;
+
+import org.openjproxy.grpc.GrpcChannelFactory;
+import com.openjproxy.grpc.ConnectionDetails;
+import com.openjproxy.grpc.SessionInfo;
+import com.openjproxy.grpc.StatementServiceGrpc;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+
+import java.sql.SQLException;
+
+import static org.openjproxy.grpc.client.GrpcExceptionHandler.handle;
+
+public class StatementGrpcClient {
+    public static void main(String[] args) throws SQLException {
+            ManagedChannel channel = GrpcChannelFactory.createChannel("localhost", 8080);
+
+        StatementServiceGrpc.StatementServiceBlockingStub stub
+                = StatementServiceGrpc.newBlockingStub(channel);
+
+        try {
+            SessionInfo sessionInfo = stub.connect(ConnectionDetails.newBuilder()
+                    .setUrl("jdbc:ojp_h2:~/test")
+                    .setUser("sa")
+                    .setPassword("").build());
+            sessionInfo.getConnHash();
+        } catch (StatusRuntimeException e) {
+            handle(e);
+        }
+        channel.shutdown();
+    }
+}