session.go

package netpipe

import (
	"sync"
	"time"

	"github.com/google/uuid"
)

// Session resumption allows a client to reconnect and be recognized as the
// same logical client. The server assigns a session UUID on first connect,
// the client stores it, and sends it back on reconnect.
//
// Wire: server sends [flagSession][16B UUID] after accept.
//       client sends [flagSession][16B UUID] as first frame on reconnect.
//
// If the server recognizes the session, the client gets the same ID.
// Sessions expire after sessionTTL if not resumed.

const (
	sessionUUIDSize = 16
	sessionTTL      = 5 * time.Minute // how long a disconnected session is kept
)

// sessionEntry tracks one session.
type sessionEntry struct {
	clientID  string
	createdAt time.Time
	lastSeen  time.Time
}

// sessionRegistry manages session state on the server.
type sessionRegistry struct {
	mu       sync.Mutex
	sessions map[string]*sessionEntry // key = session UUID string
}

func newSessionRegistry() *sessionRegistry {
	return &sessionRegistry{
		sessions: make(map[string]*sessionEntry),
	}
}

// create makes a new session for a client. Returns the session UUID string.
func (sr *sessionRegistry) create(clientID string) string {
	sr.mu.Lock()
	defer sr.mu.Unlock()

	// clean up expired sessions
	sr.cleanExpiredLocked()

	sessionID := uuid.New().String()
	sr.sessions[sessionID] = &sessionEntry{
		clientID:  clientID,
		createdAt: time.Now(),
		lastSeen:  time.Now(),
	}
	return sessionID
}

// resume looks up a session by ID. If found and not expired, returns the
// original clientID and true. Otherwise returns empty and false.
func (sr *sessionRegistry) resume(sessionID string) (string, bool) {
	sr.mu.Lock()
	defer sr.mu.Unlock()

	sr.cleanExpiredLocked()

	entry, ok := sr.sessions[sessionID]
	if !ok {
		return "", false
	}

	entry.lastSeen = time.Now()
	return entry.clientID, true
}

// touch updates the last-seen time for a session.
func (sr *sessionRegistry) touch(sessionID string) {
	sr.mu.Lock()
	if entry, ok := sr.sessions[sessionID]; ok {
		entry.lastSeen = time.Now()
	}
	sr.mu.Unlock()
}

// remove deletes a session.
func (sr *sessionRegistry) remove(sessionID string) {
	sr.mu.Lock()
	delete(sr.sessions, sessionID)
	sr.mu.Unlock()
}

func (sr *sessionRegistry) cleanExpiredLocked() {
	now := time.Now()
	for id, entry := range sr.sessions {
		if now.Sub(entry.lastSeen) > sessionTTL {
			delete(sr.sessions, id)
		}
	}
}