Go로 PostgreSQL 프록시 만들기 (24) - 좀비 고루틴과 Dangling Pointer

시나리오:

1) Client: POST /v1/query { "sql": "SELECT * FROM huge_table" }
2) pgmux: Pool에서 커넥션 획득 → executeQuery() 시작 (블로킹 read)
3) Client: 1초 후 브라우저 탭 닫음 → ctx.Cancel() 발생
4) pgmux: ctx가 취소되었지만, executeQuery()는 DB 응답을 기다리며 영원히 블로킹!
5) 결과: 고루틴 1개 + DB 커넥션 1개 = 좀비 💀

// AS-IS: ctx 취소를 전혀 감시하지 않음
func (s *Server) executeOnPool(ctx context.Context, sql string, p *pool.Pool) (*QueryResponse, error) {
    conn, err := p.Acquire(ctx) // ctx를 존중 ✓
    if err != nil { return nil, err }

    resp, execErr := executeQuery(conn, sql) // ← ctx가 취소되어도 DB 응답까지 무한 블로킹!
    // ...
    drainUntilReady(conn)                     // ← 여기서도 블로킹!
    p.Release(conn)
    return resp, nil
}

// TO-BE: 워치독으로 context 취소 감시
func (s *Server) executeOnPool(ctx context.Context, sql string, p *pool.Pool) (*QueryResponse, error) {
    conn, err := p.Acquire(ctx)
    if err != nil { return nil, err }

    // 워치독 고루틴: ctx 취소 시 커넥션 deadline 강제 설정
    var cancelled atomic.Bool
    stopCh := make(chan struct{})
    watchdogDone := make(chan struct{})
    go func() {
        defer close(watchdogDone)
        select {
        case <-ctx.Done():
            cancelled.Store(true)
            conn.SetDeadline(time.Now()) // 블로킹 read를 즉시 실패시킴
        case <-stopCh:
            // 정상 완료 — 워치독 종료
        }
    }()

    stopWatchdog := func() {
        close(stopCh)
        <-watchdogDone
    }

    resp, execErr := executeQuery(conn, sql)

    // ctx가 취소된 경우: 커넥션을 Discard하고 에러 반환
    if cancelled.Load() {
        <-watchdogDone
        p.Discard(conn)
        return nil, fmt.Errorf("execute query: %w", ctx.Err())
    }

    if execErr != nil {
        stopWatchdog()
        p.Discard(conn)
        return nil, execErr
    }

    // reset query도 동일하게 워치독이 커버
    drainErr := drainUntilReady(conn)
    if cancelled.Load() {
        <-watchdogDone
        p.Discard(conn)
        return nil, fmt.Errorf("drain reset: %w", ctx.Err())
    }

    stopWatchdog()
    p.Release(conn)
    return resp, nil
}

시나리오:

1) main.go: adminSrv := admin.New(cfg, srv.WriterPool(), srv.ReaderPools(), ...)
   → 초기화 시점의 포인터 값을 Admin 서버에 복사

2) POST /admin/reload → srv.Reload(newCfg)
   → s.readerPools = newReaderPools (새 맵으로 교체)
   → 기존 removed pool.Close() (커넥션 전부 해제)

3) GET /admin/stats
   → Admin 서버: s.readerPools 접근 (예전 맵!)
   → 닫힌 풀의 Stats() → open: 0, idle: 0 💀 유령 데이터

// AS-IS: 초기화 시점의 포인터 값 전달
adminSrv := admin.New(
    cfg,
    srv.Cache(),       // ← 호출 결과인 *cache.Cache 값을 복사
    srv.Invalidator(),
    srv.WriterPool(),  // ← 호출 결과인 *pool.Pool 값을 복사
    srv.ReaderPools(), // ← 호출 결과인 map[string]*pool.Pool 값을 복사
    srv.AuditLogger(),
)

// AS-IS: 포인터를 직접 저장
type Server struct {
    cfg         *config.Config
    cache       *cache.Cache
    writerPool  *pool.Pool
    readerPools map[string]*pool.Pool
    // ...
}

// TO-BE: getter 함수로 최신 객체 접근
type Server struct {
    cfgFn         func() *config.Config
    cacheFn       func() *cache.Cache
    writerPoolFn  func() *pool.Pool
    readerPoolsFn func() map[string]*pool.Pool
    auditLoggerFn func() *audit.Logger
    // ...
}

func New(
    cfgFn func() *config.Config,
    cacheFn func() *cache.Cache,
    // ...
) *Server {
    return &Server{
        cfgFn:   cfgFn,
        cacheFn: cacheFn,
        // ...
    }
}

func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
    writerPool := s.writerPoolFn()   // 매 요청마다 최신 풀 획득
    readerPools := s.readerPoolsFn() // 매 요청마다 최신 맵 획득

    if writerPool != nil {
        wOpen, wIdle := writerPool.Stats()
        // ...
    }
}

// TO-BE: 메서드 참조 전달 (호출하지 않음!)
adminSrv := admin.New(
    srv.Cfg,          // func() *config.Config — 호출할 때마다 최신 config
    srv.Cache,        // func() *cache.Cache
    srv.Invalidator,  // func() *cache.Invalidator
    srv.WriterPool,   // func() *pool.Pool
    srv.ReaderPools,  // func() map[string]*pool.Pool — mutex 보호된 getter
    srv.AuditLogger,  // func() *audit.Logger
)

func (s *Server) ReaderPools() map[string]*pool.Pool {
    return s.getReaderPools() // 내부에서 s.mu.RLock/RUnlock
}