DNS·IP·TCP·UDP와 연결 경계

rootProject.name = 'http-basics'

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation platform('org.springframework:spring-framework-bom:6.2.11')
    implementation 'org.springframework:spring-webmvc'

    testImplementation platform('org.junit:junit-bom:5.13.4')
    testImplementation platform('com.fasterxml.jackson:jackson-bom:2.18.4.1')
    testImplementation 'org.springframework:spring-test'
    testImplementation 'jakarta.servlet:jakarta.servlet-api:6.0.0'
    testImplementation 'jakarta.validation:jakarta.validation-api:3.0.2'
    testImplementation 'com.fasterxml.jackson.core:jackson-databind'
    testImplementation 'org.junit.jupiter:junit-jupiter'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.release = 17
}

tasks.named('test') {
    useJUnitPlatform()
}

package example.network;

import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;

@Timeout(value = 5, unit = SECONDS)
class NameResolutionTest {
    @Test
    void localhost는_구성된_이름_서비스에서_루프백_후보를_제공한다()
            throws Exception {
        var addresses = InetAddress.getAllByName("localhost");

        assertTrue(addresses.length > 0);
        assertTrue(Arrays.stream(addresses)
                .anyMatch(InetAddress::isLoopbackAddress));
    }

    @Test
    void 이름_해석_실패는_주입한_리졸버로_분류한다() {
        Resolver resolver = ignored -> {
            throw new UnknownHostException();
        };

        assertThrows(
                UnknownHostException.class,
                () -> resolver.resolve("board.example"));
    }

    @FunctionalInterface
    private interface Resolver {
        InetAddress[] resolve(String name) throws UnknownHostException;
    }
}

package example.network;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;

@Timeout(value = 8, unit = SECONDS)
class TcpLineExchangeTest {
    private static final int IO_TIMEOUT_MILLIS = 2_000;

    @Test
    void 두_write는_CRLF로_끝나는_하나의_HTTP1_요청_라인이_된다()
            throws Exception {
        var loopback = InetAddress.getLoopbackAddress();
        ExecutorService executor = Executors.newSingleThreadExecutor();
        try {
            try (var server = listen(loopback)) {
                var accepted = executor.submit(() -> {
                    try (var socket = server.accept()) {
                        socket.setSoTimeout(IO_TIMEOUT_MILLIS);
                        var reader = new BufferedReader(new InputStreamReader(
                                socket.getInputStream(), UTF_8));
                        var writer = new BufferedWriter(new OutputStreamWriter(
                                socket.getOutputStream(), UTF_8));
                        var requestLine = reader.readLine();
                        writer.write("HTTP/1.1 204 No Content\r\n");
                        writer.flush();
                        return requestLine;
                    }
                });

                try (var client = connect(loopback, server.getLocalPort())) {
                    var output = client.getOutputStream();
                    output.write("GET /api/posts/42".getBytes(UTF_8));
                    output.write(" HTTP/1.1\r\n".getBytes(UTF_8));
                    output.flush();

                    var reader = new BufferedReader(new InputStreamReader(
                            client.getInputStream(), UTF_8));
                    assertEquals(
                            "HTTP/1.1 204 No Content",
                            reader.readLine());
                }

                assertEquals(
                        "GET /api/posts/42 HTTP/1.1",
                        accepted.get(3, SECONDS));
            }
        } finally {
            stop(executor);
        }
    }

    @Test
    void 한_write의_두_줄은_애플리케이션_CRLF로_나뉜다()
            throws Exception {
        var loopback = InetAddress.getLoopbackAddress();
        ExecutorService executor = Executors.newSingleThreadExecutor();
        try {
            try (var server = listen(loopback)) {
                var accepted = executor.submit(() -> {
                    try (var socket = server.accept()) {
                        socket.setSoTimeout(IO_TIMEOUT_MILLIS);
                        var writer = new BufferedWriter(new OutputStreamWriter(
                                socket.getOutputStream(), UTF_8));
                        writer.write("alpha\r\nbeta\r\n");
                        writer.flush();
                    }
                    return true;
                });

                try (var client = connect(loopback, server.getLocalPort())) {
                    var reader = new BufferedReader(new InputStreamReader(
                            client.getInputStream(), UTF_8));
                    assertEquals("alpha", reader.readLine());
                    assertEquals("beta", reader.readLine());
                }

                assertTrue(accepted.get(3, SECONDS));
            }
        } finally {
            stop(executor);
        }
    }

    private static ServerSocket listen(InetAddress address)
            throws IOException {
        var server = new ServerSocket(0, 1, address);
        server.setSoTimeout(IO_TIMEOUT_MILLIS);
        return server;
    }

    private static Socket connect(InetAddress address, int port)
            throws IOException {
        var socket = new Socket();
        socket.connect(
                new InetSocketAddress(address, port),
                IO_TIMEOUT_MILLIS);
        socket.setSoTimeout(IO_TIMEOUT_MILLIS);
        return socket;
    }

    private static void stop(ExecutorService executor)
            throws InterruptedException {
        executor.shutdownNow();
        if (!executor.awaitTermination(3, SECONDS)) {
            fail("executor did not terminate");
        }
    }
}

package example.network;

import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Timeout;

@Timeout(value = 5, unit = SECONDS)
class UdpLoopbackTest {
    private static final int RECEIVE_TIMEOUT_MILLIS = 2_000;

    @Test
    void 데이터그램_단위와_작은_수신_버퍼의_잘림을_관찰한다()
            throws Exception {
        var loopback = InetAddress.getLoopbackAddress();
        try (var receiver = new DatagramSocket(0, loopback);
                var sender = new DatagramSocket()) {
            receiver.setSoTimeout(RECEIVE_TIMEOUT_MILLIS);

            send(sender, loopback, receiver.getLocalPort(), "pulse");
            var complete = new DatagramPacket(new byte[32], 32);
            receiver.receive(complete);
            assertEquals("pulse", text(complete));

            var original = "board-heartbeat";
            send(sender, loopback, receiver.getLocalPort(), original);
            var truncated = new DatagramPacket(new byte[5], 5);
            receiver.receive(truncated);
            assertEquals("board", text(truncated));
            assertTrue(original.getBytes(UTF_8).length
                    > truncated.getLength());
        }
    }

    private static void send(
            DatagramSocket sender,
            InetAddress address,
            int port,
            String text) throws Exception {
        var bytes = text.getBytes(UTF_8);
        sender.send(new DatagramPacket(
                bytes, bytes.length, address, port));
    }

    private static String text(DatagramPacket packet) {
        return new String(
                packet.getData(),
                packet.getOffset(),
                packet.getLength(),
                UTF_8);
    }
}