refactoring

server-new/build.gradle

@@ -24,9 +24,13 @@ application {
 
 dependencies {
     implementation project(':cli-parser')
+    implementation project(':protocol-new')
 
     implementation libs.logger.logback
     implementation libs.hocon
+
+    implementation libs.netty.transport
+    implementation libs.netty.handler
 }
 
 shadowJar {

server-new/src/main/java/mc/server/Main.java

@@ -8,9 +8,18 @@ import lombok.SneakyThrows;
 import mc.cliparser.CommandLine;
 import mc.cliparser.CommandLineParser;
 import mc.cliparser.Option;
-import mc.server.di.ConfigComponent;
-import mc.server.di.ConfigModule;
-import mc.server.di.DaggerConfigComponent;
+import mc.protocol.ProtocolAttributes;
+import mc.protocol.ProtocolConstant;
+import mc.protocol.State;
+import mc.protocol.handler.PacketProcessor;
+import mc.protocol.model.ServerInfo;
+import mc.protocol.model.ServerInfoSerializer;
+import mc.protocol.model.text.TextSerializer;
+import mc.protocol.packets.KeepAlivePacket;
+import mc.protocol.packets.handshaking.client.HandshakePacket;
+import mc.protocol.packets.status.client.StatusServerRequestPacket;
+import mc.protocol.packets.status.server.StatusServerResponse;
+import mc.server.di.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -22,6 +31,7 @@ import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Collections;
 import java.util.Objects;
 
 public class Main {
@@ -52,11 +62,11 @@ public class Main {
 				commandLine.has(configOption) ? Paths.get(configOption.value()) : null);
 		ConfigComponent configComponent = DaggerConfigComponent.builder()
 				.configModule(configModule).build();
-		Config config = configComponent.getConfig();
 		//endregion
 
 		Logger log = LoggerFactory.getLogger("LAUNCHER");
 		if (log.isDebugEnabled()) {
+			Config config = configComponent.getConfig();
 			log.debug("Logback config path: {}", logconfigOption.value() == null ? "(default)" : logconfigOption.value());
 			log.debug("Config path: {}", configOption.value() == null ? "(default)" : configOption.value());
 
@@ -65,8 +75,18 @@ public class Main {
 					.sorted()
 					.forEach(log::debug);
 		}
+
+		ServerComponent serverComponent = DaggerServerComponent.create();
+		setupPacketProcessor(serverComponent, configComponent);
+
+		Config config = configComponent.getConfig();
+		NettyServer server = serverComponent.getNettyServer();
+
+		log.info("Server starting: {}:{}", config.getString("server.host"), config.getInt("server.port"));
+		server.start(config.getString("server.host"), config.getInt("server.port"));
 	}
 
+	//TODO нужно продумать как этот метод сделать доступным для расширенных версий сервера
 	/**
 	 * Перенастраиваем logback с учетом путей.
 	 * <p>По-умолчанию, logback пытается искать свои конфиги по заранее зашитым путям.
@@ -94,4 +114,37 @@ public class Main {
 		URL url = Objects.requireNonNull(Main.class.getResource("/logback-default.xml"));
 		return Paths.get(url.toURI());
 	}
+
+	private static void setupPacketProcessor(ServerComponent serverComponent, ConfigComponent configComponent) {
+		PacketProcessor packetProcessor = serverComponent.getPacketProcessor();
+
+		packetProcessor.addHandler(State.HANDSHAKING, HandshakePacket.class,
+				(ctx, packet) -> ctx.channel().attr(ProtocolAttributes.STATE).set(packet.getNextState()));
+
+		setupStatusPacketProcessor(packetProcessor, configComponent);
+	}
+
+	private static void setupStatusPacketProcessor(PacketProcessor packetProcessor, ConfigComponent configComponent) {
+		Config config = configComponent.getConfig();
+
+		packetProcessor
+				.addHandler(State.STATUS, KeepAlivePacket.class, (ctx, packet) -> {
+					ctx.writeAndFlush(packet);
+					ctx.close();
+				})
+				.addHandler(State.STATUS, StatusServerRequestPacket.class, (ctx, packet) -> {
+					ServerInfo serverInfo = new ServerInfo();
+					serverInfo.version().name(ProtocolConstant.PROTOCOL_NAME);
+					serverInfo.version().protocol(ProtocolConstant.PROTOCOL_NUMBER);
+					serverInfo.players().max(config.getInt("players.max-online"));
+					serverInfo.players().online(config.getInt("players.fake-online.value"));
+					serverInfo.players().sample(Collections.emptyList());
+					serverInfo.description(TextSerializer.fromPlain(config.getString("motd")));
+
+					StatusServerResponse response = new StatusServerResponse();
+					response.setInfo(ServerInfoSerializer.toStringPlain(serverInfo));
+
+					ctx.writeAndFlush(response);
+				});
+	}
 }

server-new/src/main/java/mc/server/NettyServer.java

@@ -0,0 +1,55 @@
+package mc.server;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import mc.protocol.handler.PacketProcessor;
+import mc.protocol.handler.ProtocolInboundHandler;
+import mc.protocol.handler.codec.ProtocolDecoder;
+import mc.protocol.handler.codec.ProtocolEncoder;
+import mc.protocol.handler.codec.ProtocolSplitter;
+
+import javax.annotation.Nonnull;
+
+@Slf4j
+@RequiredArgsConstructor
+public class NettyServer {
+
+	private final PacketProcessor packetProcessor;
+
+	public void start(String host, int port) {
+		try {
+			createServerBootstrap().bind(host, port).sync().channel().closeFuture().sync();
+		} catch (InterruptedException e) {
+			if (log.isTraceEnabled()) {
+				log.trace("{}: {}", e.getClass().getSimpleName(), e.getMessage(), e);
+			}
+		}
+	}
+
+	private ServerBootstrap createServerBootstrap() {
+		ServerBootstrap bootstrap = new ServerBootstrap();
+
+		bootstrap.group(new NioEventLoopGroup(1), new NioEventLoopGroup())
+				.channel(NioServerSocketChannel.class)
+				.childHandler(new ChannelInitializer<SocketChannel>() {
+					@Override
+					protected void initChannel(@Nonnull SocketChannel socketChannel) {
+						socketChannel.pipeline()
+								.addLast("packet_splitter", new ProtocolSplitter())
+								.addLast("logger", new LoggingHandler(LogLevel.DEBUG))
+								.addLast("packet_decoder", new ProtocolDecoder())
+								.addLast("packet_encoder", new ProtocolEncoder())
+								.addLast("packet_handler", new ProtocolInboundHandler(packetProcessor));
+					}
+				});
+
+		return bootstrap;
+	}
+}

server-new/src/main/java/mc/server/di/ServerComponent.java

@@ -0,0 +1,15 @@
+package mc.server.di;
+
+import dagger.Component;
+import mc.protocol.handler.PacketProcessor;
+import mc.server.NettyServer;
+
+import javax.inject.Singleton;
+
+@Component(modules = ServerModule.class)
+@Singleton
+public interface ServerComponent {
+
+	PacketProcessor getPacketProcessor();
+	NettyServer getNettyServer();
+}

server-new/src/main/java/mc/server/di/ServerModule.java

@@ -0,0 +1,24 @@
+package mc.server.di;
+
+import dagger.Module;
+import dagger.Provides;
+import mc.protocol.handler.PacketProcessor;
+import mc.server.NettyServer;
+
+import javax.inject.Singleton;
+
+@Module
+public class ServerModule {
+
+	@Provides
+	@Singleton
+	PacketProcessor providePacketProcessor() {
+		return new PacketProcessor();
+	}
+
+	@Provides
+	@Singleton
+	NettyServer provideNettyServer(PacketProcessor packetProcessor) {
+		return new NettyServer(packetProcessor);
+	}
+}