WIP

main.go

@@ -34,7 +34,8 @@
 // This will allow distributed content delivery but put a memory and bendwidth strain on the
 // bootstrap sever. Look into Web Transport for the raspberry pi overhead. Could buy a few more RPIs
 // and make a little cluster
-// Domain name so we can get a certificate and serve HTTPS / HTTP3
+
+// ✅ Domain name so we can get a certificate and serve HTTPS / HTTP3
 
 // Think about compiling Typescript on initial access and caching the JS in a service worker
 // so you don't need a build system to change things.
@@ -43,23 +44,59 @@
 package main
 
 import (
+	"encoding/json"
+	"fmt"
+	"io"
 	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strconv"
+	"strings"
 
+	"github.com/andybalholm/brotli"
 	"github.com/gorilla/websocket"
-	"github.com/quic-go/quic-go/http3"
 )
 
 var upgrader = websocket.Upgrader{
 	CheckOrigin: func(r *http.Request) bool {
-		return true // Note: In production, you'd want to check the origin.
+		origin := r.Header.Get("Origin")
+		return origin == "https://ddlion.net"
 	},
 }
 
-// handleWebSocket handles WebSocket requests from the peer.
+func websocketCloseHandler(code int, text string) error {
+	log.Print("Client closed websocket.")
+	return nil
+}
+
+type Message struct {
+	Type string `json:"type"`
+}
+
+type MessageHandler func([]byte, *websocket.Conn) error
+
+var messageHandlers = make(map[string]MessageHandler)
+
+func registerHandler(messageType string, handler MessageHandler) {
+	messageHandlers[messageType] = handler
+}
+
+func dispatchMessage(message []byte, conn *websocket.Conn) error {
+	var msg Message
+	if err := json.Unmarshal(message, &msg); err != nil {
+		return err
+	}
+
+	handler, ok := messageHandlers[msg.Type]
+	if !ok {
+		log.Printf("No handler registered for message type: %s", msg.Type)
+		return nil
+	}
+
+	return handler(message, conn)
+}
+
 func handleWebSocket(w http.ResponseWriter, r *http.Request) {
 	log.Println("Websocket connection!", r.RemoteAddr)
 
@@ -70,47 +107,126 @@ func handleWebSocket(w http.ResponseWriter, r *http.Request) {
 	}
 	defer conn.Close()
 
+	conn.SetCloseHandler(websocketCloseHandler)
+
 	for {
-		mt, message, err := conn.ReadMessage()
+		_, message, err := conn.ReadMessage()
 		if err != nil {
-			log.Println("Read error:", err)
+			log.Println("ReadMessage error:", err)
 			break
 		}
 		log.Printf("recv: %s", message)
 
-		err = conn.WriteMessage(mt, message)
-		if err != nil {
-			log.Println("Write error:", err)
-			break
+		if err := dispatchMessage(message, conn); err != nil {
+			log.Printf("Error dispatching message: %v", err)
 		}
 	}
 }
 
-// LoggingHandler logs requests and delegates them to the underlying handler.
-type LoggingHandler struct {
-	handler http.Handler
+// Example handlers
+func handlePing(message []byte, conn *websocket.Conn) error {
+	var pingMsg struct {
+		Type   string `json:"type"`
+		PeerID string `json:"peer_id"`
+	}
+	if err := json.Unmarshal(message, &pingMsg); err != nil {
+		return err
+	}
+	log.Printf("Received ping from peer: %s", pingMsg.PeerID)
+	return nil
 }
 
-func (lh *LoggingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	log.Printf("Serving file: %s", r.URL.Path)
-	lh.handler.ServeHTTP(w, r)
+type PeerSet map[string]struct{}
+
+var userPeers = make(map[string]PeerSet)
+var peerConnections = make(map[string]*websocket.Conn)
+
+func handleHello(message []byte, conn *websocket.Conn) error {
+
+	var m struct {
+		Type   string `json:"type"`
+		UserID string `json:"user_id"`
+		PeerID string `json:"peer_id"`
+	}
+
+	if err := json.Unmarshal(message, &m); err != nil {
+		return err
+	}
+
+	if userPeers[m.UserID] == nil {
+		userPeers[m.UserID] = make(PeerSet)
+	}
+
+	userPeers[m.UserID][m.PeerID] = struct{}{}
+	peerConnections[m.PeerID] = conn
+
+	jsonData, _ := json.MarshalIndent(userPeers, "", "  ")
+	fmt.Println(string(jsonData), peerConnections)
+
+	log.Printf("Received connect from peer: %s, user:%s", m.PeerID, m.UserID)
+	return nil
+}
+
+// LoggingHandler logs requests and delegates them to the underlying handler.
+// type LoggingHandler struct {
+// 	handler http.Handler
+// }
+
+// func (lh *LoggingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+// 	log.Printf("Serving file: %s", r.URL.Path)
+// 	lh.handler.ServeHTTP(w, r)
+// }
+
+// BrotliResponseWriter wraps http.ResponseWriter to support Brotli compression
+type brotliResponseWriter struct {
+	http.ResponseWriter
+	Writer io.Writer
+}
+
+func (w *brotliResponseWriter) Write(b []byte) (int, error) {
+	return w.Writer.Write(b)
 }
 
 // noDirListing wraps an http.FileServer handler to prevent directory listings
 func noDirListing(h http.Handler, root string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
+
 		// Serve index.html when root is requested
 		if r.URL.Path == "/" {
 			http.ServeFile(w, r, filepath.Join(root, "index.html"))
 			return
 		}
 
-		// Check if the path is a directory
 		path := filepath.Join(root, r.URL.Path)
-		if info, err := os.Stat(path); err == nil && info.IsDir() {
-			http.NotFound(w, r) // Return 404 for directories other than root
+		info, err := os.Stat(path)
+		if err != nil || info.IsDir() {
+			log.Printf("404 File not found/dir serving: %s to ip %s, useragent %s", r.URL.Path, r.RemoteAddr, r.UserAgent())
+			http.NotFound(w, r)
 			return
 		}
+
+		log.Printf("Serving: %s to ip %s, useragent %s", r.URL.Path, r.RemoteAddr, r.UserAgent())
+
+		// Check if client supports Brotli encoding
+		if strings.Contains(r.Header.Get("Accept-Encoding"), "br") {
+			w.Header().Set("Content-Encoding", "br")
+			w.Header().Del("Content-Length") // Cannot know content length with compressed data
+
+			// Wrap the ResponseWriter with Brotli writer
+			brWriter := brotli.NewWriter(w)
+			defer brWriter.Close()
+
+			// Create a ResponseWriter that writes to brWriter
+			bw := &brotliResponseWriter{
+				ResponseWriter: w,
+				Writer:         brWriter,
+			}
+
+			// Serve the file using http.ServeFile
+			http.ServeFile(bw, r, path)
+			return
+		}
+
 		h.ServeHTTP(w, r)
 	}
 }
@@ -122,8 +238,9 @@ func main() {
 	addr := ":" + strconv.Itoa(port)
 	log.Printf("Starting server on %s", addr)
 
-	// http.Handle("/", http.FileServer(http.Dir(wwwDir)))
-	// http3.ListenAndServeQUIC("localhost:4242", "/path/to/cert/chain.pem", "/path/to/privkey.pem", nil)
+	// Register handlers
+	registerHandler("hello", handleHello)
+	registerHandler("ping", handlePing)
 
 	// Set up file server and WebSocket endpoint
 	fs := http.FileServer(http.Dir(dir))
@@ -134,11 +251,11 @@ func main() {
 	http.HandleFunc("/ws", handleWebSocket)
 
 	// Configure and start the HTTP server
-	server := &http3.Server{
+	server := &http.Server{
 		Addr:    addr,
 		Handler: nil, // nil uses the default ServeMux, which we configured above
 	}
 
 	log.Printf("Server is configured and serving on port %d...", port)
-	log.Fatal(server.ListenAndServeTLS("./fullchain.pem", "./privkey.pem"))
+	log.Fatal(server.ListenAndServeTLS("/etc/letsencrypt/live/ddlion.net/fullchain.pem", "/etc/letsencrypt/live/ddlion.net/privkey.pem"))
 }