qgo-server/main.go

package main

import (
	"context"
	"log"
	"net/http"
	"strings"
	"sync"

	"github.com/caddyserver/certmagic"
	"github.com/quic-go/quic-go/http3"
	"github.com/quic-go/webtransport-go"
)

type Room struct {
	conns map[*webtransport.Session]bool
	mu    sync.Mutex
}

type Server struct {
	rooms map[string]*Room
	mu    sync.Mutex
}

func NewServer() *Server {
	return &Server{rooms: make(map[string]*Room)}
}

func (s *Server) getRoom(name string) *Room {
	s.mu.Lock()
	defer s.mu.Unlock()
	if room, ok := s.rooms[name]; ok {
		return room
	}
	room := &Room{conns: make(map[*webtransport.Session]bool)}
	s.rooms[name] = room
	return room
}

func (s *Server) handleSession(roomName string, sess *webtransport.Session) {
	room := s.getRoom(roomName)
	room.mu.Lock()
	room.conns[sess] = true
	room.mu.Unlock()

	log.Printf("Joined room: %s", roomName)
	defer func() {
		room.mu.Lock()
		delete(room.conns, sess)
		room.mu.Unlock()
		log.Printf("Left room: %s", roomName)
	}()

	for {
		stream, err := sess.AcceptStream(context.Background())
		if err != nil {
			return
		}
		go s.handleStream(room, sess, stream)
	}
}

func (s *Server) handleStream(room *Room, sender *webtransport.Session, stream *webtransport.Stream) {
	buf := make([]byte, 4096)
	for {
		n, err := stream.Read(buf)
		if err != nil {
			return
		}
		data := append([]byte(nil), buf[:n]...)

		room.mu.Lock()
		for conn := range room.conns {
			if conn == sender {
				continue
			}
			go func(c *webtransport.Session, d []byte) {
				out, err := c.OpenStream()
				if err != nil {
					return
				}
				defer out.Close()
				out.Write(d)
			}(conn, data)
		}
		room.mu.Unlock()
	}
}

func main() {
	domain := "qgo-server.quizer.space"
	email := "serverussnap@outlook.com"

	// Настройка CertMagic (как в вашем рабочем коде)
	certmagic.DefaultACME.Email = email
	certmagic.DefaultACME.Agreed = true
	certmagic.Default.Storage = &certmagic.FileStorage{Path: "/root/.local/share/certmagic"}

	server := NewServer()

	// Настройка WebTransport
	wt := &webtransport.Server{
		H3: &http3.Server{
			Addr:            ":443",
			EnableDatagrams: true, // Важно для WebTransport
		},
		CheckOrigin: func(r *http.Request) bool { return true },
	}

	mux := http.NewServeMux()
	mux.HandleFunc("/room/", func(w http.ResponseWriter, r *http.Request) {
		// Обязательный заголовок для браузера
		w.Header().Set("Alt-Svc", `h3=":443"; ma=2592000`)

		roomName := strings.TrimPrefix(r.URL.Path, "/room/")

		// Попытка апгрейда
		sess, err := wt.Upgrade(w, r)
		if err != nil {
			log.Printf("Upgrade error: %v", err)
			return
		}
		go server.handleSession(roomName, sess)
	})

	log.Printf("Starting server on %s", domain)

	// Используем certmagic.HTTPS, который сам создаст нужный TLSConfig
	// и запустит HTTP/3 (UDP) + HTTPS (TCP) корректно.
	err := certmagic.HTTPS([]string{domain}, mux)
	if err != nil {
		log.Fatalf("Server failed: %v", err)
	}
}