fix: Velocity injection

- Updated Lombok version from 6.3.0 to 8.6 in build.gradle.kts
- Added .DS_Store to .gitignore
- Introduced .vscode/settings.json for Java null analysis configuration
- Set Java source and target compatibility to 1.8 in build-logic/build.gradle.kts
- Updated nettyVersion from 4.1.49.Final to 4.2.3.Final in Versions.kt
- Upgraded Gradle wrapper to version 8.5
- Added ConnectWatchedSingleThreadIoEventLoop for custom event loop handling in VelocityInjector.java
- Refactored VelocityInjector to use LocalIoHandler-based event loops for better compatibility

Author: robinbraemer

.gitignore

@@ -13,6 +13,7 @@ local.properties
 .settings/
 .loadpath
 .recommenders
+.DS_Store
 
 # External tool builders
 .externalToolBuilders/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "java.compile.nullAnalysis.mode": "automatic"
+}

build-logic/build.gradle.kts

@@ -14,6 +14,11 @@ dependencies {
     implementation("gradle.plugin.com.github.johnrengelman", "shadow", "7.1.1")
 }
 
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
 tasks.withType<KotlinCompile> {
     kotlinOptions {
         jvmTarget = "1.8"

build-logic/src/main/kotlin/Versions.kt

@@ -27,7 +27,7 @@ object Versions {
     const val spigotVersion = "1.19.4-R0.1-SNAPSHOT"
     const val configUtilsVersion = "1.0-SNAPSHOT"
     const val guiceVersion = "6.0.0"
-    const val nettyVersion = "4.1.49.Final"
+    const val nettyVersion = "4.2.3.Final"
     const val snakeyamlVersion = "1.28"
     const val cloudVersion = "1.5.0"
     const val adventureApiVersion = "4.10.0"

build.gradle.kts

@@ -1,7 +1,7 @@
 plugins {
     `java-library`
     id("connect.build-logic")
-    id("io.freefair.lombok") version "6.3.0" apply false
+    id("io.freefair.lombok") version "8.6" apply false
 }
 
 allprojects {

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

velocity/src/main/java/com/minekube/connect/inject/velocity/ConnectWatchedSingleThreadIoEventLoop.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2019-2022 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Geyser
+ */
+
+package com.minekube.connect.inject.velocity;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.IoEventLoopGroup;
+import io.netty.channel.IoHandlerFactory;
+import io.netty.channel.SingleThreadIoEventLoop;
+
+import java.util.concurrent.Executor;
+
+public class ConnectWatchedSingleThreadIoEventLoop extends SingleThreadIoEventLoop {
+    private final EventLoopGroup trueWorkerGroup;
+
+    public ConnectWatchedSingleThreadIoEventLoop(EventLoopGroup trueWorkerGroup, IoEventLoopGroup parent,
+                                          Executor executor, IoHandlerFactory ioHandlerFactory) {
+        super(parent, executor, ioHandlerFactory);
+        this.trueWorkerGroup = trueWorkerGroup;
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public ChannelFuture register(Channel channel) {
+        if (channel.getClass().getName().startsWith("com.minekube.connect")) {
+            return super.register(channel);
+        }
+        // Starting with Netty 4.2, channels/event loops are very picky with what can be accepted for each.
+        // For example, IoUringIoHandler (on a Linux machine, what Velocity's worker group will be)
+        // will not accept LocalChannels on bootstrap creation in VelocityInjector.
+        // And using a MultiThreadEventLoopGroup with LocalIoHandler will throw an error when trying to
+        // connect to the backend server.
+        // Inserting ourselves here allows our local channels to use the event loop made for LocalChannels,
+        // while re-using the settings and style of Velocity.
+        return this.trueWorkerGroup.register(channel);
+    }
+}

velocity/src/main/java/com/minekube/connect/inject/velocity/VelocityInjector.java

@@ -40,8 +40,15 @@
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
+import io.netty.channel.IoEventLoop;
+import io.netty.channel.IoHandlerFactory;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
 import io.netty.channel.WriteBufferWaterMark;
 import io.netty.channel.local.LocalAddress;
+import io.netty.channel.local.LocalIoHandler;
+import io.netty.util.concurrent.DefaultThreadFactory;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ThreadFactory;
 import java.lang.reflect.Method;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -86,13 +93,33 @@ public boolean inject() {
         WriteBufferWaterMark serverWriteMark = getCastedValue(connectionManager,
                 "SERVER_WRITE_MARK");
 
-        EventLoopGroup bossGroup = castedInvoke(connectionManager, "getBossGroup");
-        EventLoopGroup workerGroup = getCastedValue(connectionManager, "workerGroup");
+        // Use LocalIoHandler-based event loops that are compatible with LocalServerChannel
+        // while still integrating with Velocity's system (Geyser approach with ConnectWatchedSingleThreadIoEventLoop)
+        EventLoopGroup velocityWorkerGroup = getCastedValue(connectionManager, "workerGroup");
+        
+        EventLoopGroup localBossGroup = new MultiThreadIoEventLoopGroup(LocalIoHandler.newFactory()) {
+            @Override
+            protected ThreadFactory newDefaultThreadFactory() {
+                return new DefaultThreadFactory("Connect Local Boss Group");
+            }
+        };
+        
+        EventLoopGroup localWorkerGroup = new MultiThreadIoEventLoopGroup(LocalIoHandler.newFactory()) {
+            @Override
+            protected ThreadFactory newDefaultThreadFactory() {
+                return new DefaultThreadFactory("Connect Local Worker Group");
+            }
+
+            @Override
+            protected IoEventLoop newChild(Executor executor, IoHandlerFactory ioHandlerFactory, Object... args) {
+                return new ConnectWatchedSingleThreadIoEventLoop(velocityWorkerGroup, this, executor, ioHandlerFactory);
+            }
+        };
 
         ChannelFuture channelFuture = (new ServerBootstrap()
                 .channel(LocalServerChannelWrapper.class)
                 .childHandler(serverInitializer)
-                .group(bossGroup, workerGroup) // Cannot be DefaultEventLoopGroup
+                .group(localBossGroup, localWorkerGroup) // Use LocalIoHandler-based event loops
                 .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK,
                         serverWriteMark) // Required or else rare network freezes can occur
                 .localAddress(LocalAddress.ANY))