타임아웃 & 유휴 감지

정상 종료:
[클라이언트] --FIN--> [서버]    양쪽이 FIN을 주고받으며 깔끔하게 종료

비정상 종료:
[클라이언트] --전원 꺼짐--> [서버]    FIN 패킷을 보내지 못함
                                   서버는 연결이 살아있다고 착각
                                   → 좀비 연결

// IdleStateHandler 생성자
new IdleStateHandler(
    60,  // readerIdleTime — 60초 동안 읽기 없으면 READER_IDLE 이벤트
    30,  // writerIdleTime — 30초 동안 쓰기 없으면 WRITER_IDLE 이벤트
    0,   // allIdleTime — 0이면 비활성화 (읽기+쓰기 모두 없을 때 ALL_IDLE)
    TimeUnit.SECONDS
);

IdleStateHandler 내부 동작 (readerIdleTime = 60초 기준)

channelActive() 호출
    │
    ├── schedule(readerIdleCheck, 60초)  ← 첫 번째 타이머 등록
    │
    │   ... 30초 후 데이터 수신 ...
    │
    ├── channelRead() → lastReadTime 갱신
    │
    │   ... 60초 타이머 만료 ...
    │
    ├── readerIdleCheck 실행
    │   │
    │   ├── 현재시간 - lastReadTime = 30초 < 60초
    │   │   → 아직 유휴 아님
    │   │   → schedule(readerIdleCheck, 30초)  ← 남은 시간만큼 재스케줄
    │   │
    │   └── (만약 현재시간 - lastReadTime >= 60초)
    │       → IdleStateEvent(READER_IDLE) 전파
    │       → schedule(readerIdleCheck, 60초)  ← 다음 주기 스케줄

// IdleStateEvent를 처리하는 핸들러
public class IdleEventHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent event) {
            switch (event.state()) {
                case READER_IDLE:
                    // 읽기 유휴 — 상대방이 데이터를 보내지 않음
                    System.out.println("읽기 유휴 감지: " + ctx.channel().remoteAddress());
                    ctx.close(); // 연결 종료
                    break;
                case WRITER_IDLE:
                    // 쓰기 유휴 — 내가 데이터를 보내지 않음
                    System.out.println("쓰기 유휴 감지 → 하트비트 전송");
                    ctx.writeAndFlush(new PingMessage());
                    break;
                case ALL_IDLE:
                    // 양방향 모두 유휴
                    System.out.println("완전 유휴 → 연결 종료");
                    ctx.close();
                    break;
            }
        } else {
            // IdleStateEvent가 아닌 다른 이벤트는 다음 핸들러로 전파
            super.userEventTriggered(ctx, evt);
        }
    }
}

ch.pipeline().addLast(new IdleStateHandler(60, 30, 0, TimeUnit.SECONDS));
ch.pipeline().addLast(new IdleEventHandler()); // 바로 뒤에 이벤트 처리 핸들러
ch.pipeline().addLast(new MyBusinessHandler());

// ReadTimeoutHandler — 30초 동안 읽기 없으면 예외 발생 + 채널 닫기
ch.pipeline().addLast(new ReadTimeoutHandler(30, TimeUnit.SECONDS));

// ReadTimeoutHandler 내부 (단순화)
public class ReadTimeoutHandler extends IdleStateHandler {

    public ReadTimeoutHandler(long timeout, TimeUnit unit) {
        super(timeout, 0, 0, unit); // readerIdleTime만 설정
    }

    @Override
    protected void channelIdle(ChannelHandlerContext ctx, IdleStateEvent evt) {
        if (evt.state() == IdleState.READER_IDLE) {
            // ReadTimeoutException 발생 → exceptionCaught()로 전파
            ctx.fireExceptionCaught(ReadTimeoutException.INSTANCE);
            // 채널 닫기
            ctx.close();
        }
    }
}

// 예외 처리 핸들러에서 ReadTimeoutException 잡기
public class ExceptionHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        if (cause instanceof ReadTimeoutException) {
            // 읽기 타임아웃 — 이미 채널이 닫히는 중
            System.out.println("읽기 타임아웃: " + ctx.channel().remoteAddress());
        } else {
            // 다른 예외 처리
            cause.printStackTrace();
            ctx.close();
        }
    }
}

// WriteTimeoutHandler — write 후 15초 내에 flush 완료되지 않으면 예외
ch.pipeline().addLast(new WriteTimeoutHandler(15, TimeUnit.SECONDS));

// WriteTimeoutHandler 내부 동작 (단순화)
// write()가 호출될 때마다 타이머를 건다
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
    // 타임아웃 스케줄 등록
    ScheduledFuture<?> timeout = ctx.executor().schedule(
        () -> {
            // 시간 내에 promise가 완료되지 않으면 예외 발생
            ctx.fireExceptionCaught(WriteTimeoutException.INSTANCE);
            ctx.close();
        },
        timeoutNanos, TimeUnit.NANOSECONDS
    );

    // write가 완료되면 타이머 취소
    promise.addListener(future -> timeout.cancel(false));

    // 실제 write 실행
    ctx.write(msg, promise);
}

하트비트 동작 흐름

[클라이언트]                           [서버]
    │                                   │
    │  (30초간 쓸 데이터 없음)             │
    │                                   │
    ├── WRITER_IDLE 감지                 │
    │                                   │
    ├──── PING ─────────────────────────▶│
    │                                   ├── 읽기 활동으로 인식 (타이머 리셋)
    │◀──────────────────────── PONG ─────┤
    │                                   │
    ├── 읽기 활동으로 인식 (타이머 리셋)     │
    │                                   │

// 클라이언트 — 쓰기 유휴 시 ping 전송
public class ClientHeartbeatHandler extends ChannelInboundHandlerAdapter {

    private int missedPongs = 0;
    private static final int MAX_MISSED_PONGS = 3; // pong 3번 못 받으면 연결 끊기

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent event) {
            if (event.state() == IdleState.WRITER_IDLE) {
                // 30초간 아무것도 쓰지 않았으면 ping 전송
                if (missedPongs >= MAX_MISSED_PONGS) {
                    // pong을 3번 연속 못 받음 → 연결 끊기
                    System.out.println("서버 응답 없음 → 연결 종료");
                    ctx.close();
                    return;
                }
                missedPongs++;
                ctx.writeAndFlush(new PingMessage());
            }
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (msg instanceof PongMessage) {
            // pong 수신 → 카운터 리셋
            missedPongs = 0;
        } else {
            // 일반 메시지는 다음 핸들러로 전달
            ctx.fireChannelRead(msg);
        }
    }
}

// 서버 — 읽기 유휴 감지 + ping에 pong 응답
public class ServerHeartbeatHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent event) {
            if (event.state() == IdleState.READER_IDLE) {
                // 90초간 읽기 없음 → 클라이언트가 죽었다고 판단
                System.out.println("클라이언트 응답 없음 → 연결 종료: "
                    + ctx.channel().remoteAddress());
                ctx.close();
            }
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (msg instanceof PingMessage) {
            // ping 수신 → pong 응답 (읽기 타이머도 자동 리셋됨)
            ctx.writeAndFlush(new PongMessage());
        } else {
            ctx.fireChannelRead(msg);
        }
    }
}

// 클라이언트 — 쓰기 유휴 시 ping 전송
Bootstrap b = new Bootstrap();
b.handler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(new IdleStateHandler(
            0,   // readerIdleTime — 사용 안 함 (pong은 channelRead에서 처리)
            30,  // writerIdleTime — 30초간 쓰기 없으면 ping 전송
            0,   // allIdleTime — 사용 안 함
            TimeUnit.SECONDS
        ));
        ch.pipeline().addLast(new PingPongCodec());          // ping/pong 메시지 인코딩/디코딩
        ch.pipeline().addLast(new ClientHeartbeatHandler());  // 하트비트 로직
        ch.pipeline().addLast(new ClientBusinessHandler());   // 비즈니스 로직
    }
});

// 서버 — 읽기 유휴 감지로 죽은 클라이언트 정리
ServerBootstrap b = new ServerBootstrap();
b.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(new IdleStateHandler(
            90,  // readerIdleTime — 90초간 읽기 없으면 연결 종료
            0,   // writerIdleTime — 사용 안 함
            0,   // allIdleTime — 사용 안 함
            TimeUnit.SECONDS
        ));
        ch.pipeline().addLast(new PingPongCodec());
        ch.pipeline().addLast(new ServerHeartbeatHandler());
        ch.pipeline().addLast(new ServerBusinessHandler());
    }
});

클라이언트 writerIdleTime: 30초
서버 readerIdleTime: 90초 (30초 × 3)

시나리오:
┌─── 0초: 마지막 통신
│
├─── 30초: 클라이언트 WRITER_IDLE → ping 전송
│         (네트워크 지연으로 도착이 늦어질 수 있음)
│
├─── 60초: 클라이언트 두 번째 ping 전송
│         (여전히 도착 안 됨)
│
├─── 90초: 서버 READER_IDLE → "진짜 죽었다" 판단 → 연결 종료
│         (3번의 ping 기회를 줬는데도 아무것도 안 옴)
└

// NAT 타임아웃 대응 예시
// AWS NAT Gateway 유휴 타임아웃: 350초
// → 하트비트를 300초 이내로 설정해야 NAT가 연결을 끊지 않음
new IdleStateHandler(0, 300, 0, TimeUnit.SECONDS);

// 조합 1: 단순한 서버 — ReadTimeoutHandler만 사용
// 클라이언트가 하트비트를 보내는 구조
ch.pipeline().addLast(new ReadTimeoutHandler(90, TimeUnit.SECONDS));
ch.pipeline().addLast(new MyHandler());

// 조합 2: 양방향 하트비트 — IdleStateHandler + 커스텀 핸들러
// 가장 유연한 구조
ch.pipeline().addLast(new IdleStateHandler(90, 30, 0, TimeUnit.SECONDS));
ch.pipeline().addLast(new HeartbeatHandler());
ch.pipeline().addLast(new MyHandler());

// 조합 3: 읽기 + 쓰기 타임아웃 — 안전하게 양쪽 모두 감시
ch.pipeline().addLast(new ReadTimeoutHandler(90, TimeUnit.SECONDS));
ch.pipeline().addLast(new WriteTimeoutHandler(15, TimeUnit.SECONDS));
ch.pipeline().addLast(new MyHandler());

// 올바른 순서 — IdleStateHandler가 먼저
ch.pipeline().addLast(new IdleStateHandler(60, 0, 0, TimeUnit.SECONDS));
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4));
ch.pipeline().addLast(new MyHandler());