Method Run

internal/proxy/proxy.go:296–354

Run starts the proxy server.

()

// Run starts the proxy server.
func (p *Proxy) Run() error {
	// Start coarse clock for efficient session activity tracking
	handler.StartCoarseClock(p.ctx)

	addr, err := net.ResolveUDPAddr("udp", p.listenAddr)
	if err != nil {
		return fmt.Errorf("failed to resolve address: %w", err)
	}

	p.conn, err = net.ListenUDP("udp", addr)
	if err != nil {
		return fmt.Errorf("failed to listen: %w", err)
	}
	defer p.conn.Close()

	log.Printf("[proxy] listening on %s", p.listenAddr)
	log.Printf("[proxy] handler chain: %v", p.handlerNames())
	log.Printf("[proxy] session timeout: %ds", p.sessionTimeout.Load())

	// Start worker pool (bounded goroutines instead of unbounded per-packet)
	// Note: workerPool.Stop() is called in Stop() for proper graceful shutdown
	p.workerPool = NewWorkerPool(0, 0, p.handlePacket)
	p.workerPool.Start()

	// Start session cleanup goroutine
	go p.cleanupSessions()

	for {
		select {
		case <-p.ctx.Done():
			return nil
		default:
		}

		// Get buffer from pool (eliminates per-packet allocation)
		buf := handler.GetBuffer()

		p.conn.SetReadDeadline(time.Now().Add(1 * time.Second))
		n, clientAddr, err := p.conn.ReadFromUDP(*buf)
		if err != nil {
			handler.PutBuffer(buf)
			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
				continue
			}
			log.Printf("Read error: %v", err)
			continue
		}

		// Submit to worker pool (non-blocking with backpressure)
		// Buffer is returned to pool by worker after processing
		if !p.workerPool.Submit(WorkItem{
			ClientAddr: clientAddr,
			Packet:     (*buf)[:n],
			Buffer:     buf,
		}) {
			// Queue full - packet already dropped, buffer returned by Submit
		}
	}