init

network/udp/server.go

@@ -12,7 +12,7 @@ type Server struct {
 	bindAddr     string
 	routingTable *RoutingTable
 
-	conn   *net.UDPConn
+	conns  []*net.UDPConn
 	wg     sync.WaitGroup
 	ctx    context.Context
 	cancel context.CancelFunc
@@ -28,40 +28,44 @@ func NewServer(bindAddr string) *Server {
 	}
 }
 
-func (s *Server) run() error {
-	add, err := net.ResolveUDPAddr("udp", s.bindAddr)
-	if err != nil {
-		return fmt.Errorf("cannot resolve address: %w", err)
-	}
+func (s *Server) Run() error {
+	workerCount := runtime.NumCPU()
 
-	s.conn, err = net.ListenUDP("udp", add)
+	conns, err := listenUDP(s.bindAddr, workerCount)
 	if err != nil {
 		return fmt.Errorf("cannot listen on address: %w", err)
 	}
+	if len(conns) == 0 {
+		return fmt.Errorf("no UDP connections created")
+	}
+	s.conns = conns
+
+	for _, conn := range s.conns {
+		conn.SetReadBuffer(8 * 1024 * 1024)
+		conn.SetWriteBuffer(8 * 1024 * 1024)
+	}
 
-	s.conn.SetReadBuffer(8 * 1024 * 1024)
-	s.conn.SetWriteBuffer(8 * 1024 * 1024)
 	fmt.Println("Listening on", s.bindAddr)
 
-	for i := 0; i < runtime.NumCPU(); i++ {
+	for i, conn := range s.conns {
 		s.wg.Add(1)
-		// todo : add so_reuseport option when on unix like system
-		go s.workerLoop(i)
+		go s.workerLoop(i, conn)
 	}
 
 	return nil
 }
 
 func (s *Server) sendTo(data []byte, addr *net.UDPAddr) error {
-	if s.conn == nil {
+	if len(s.conns) == 0 || s.conns[0] == nil {
 		return fmt.Errorf("server not started")
 	}
 
-	_, err := s.conn.WriteToUDP(data, addr)
+	// On utilise la première conn pour l’envoi (c’est suffisant pour UDP).
+	_, err := s.conns[0].WriteToUDP(data, addr)
 	return err
 }
 
-func (s *Server) workerLoop(id int) {
+func (s *Server) workerLoop(id int, conn *net.UDPConn) {
 	defer s.wg.Done()
 
 	buffer := make([]byte, 1500)
@@ -73,7 +77,7 @@ func (s *Server) workerLoop(id int) {
 			fmt.Println("Worker", id, "stopped")
 			return
 		default:
-			size, addr, err := s.conn.ReadFromUDP(buffer)
+			size, addr, err := conn.ReadFromUDP(buffer)
 			if err != nil {
 				if s.ctx.Err() != nil {
 					return
@@ -81,7 +85,7 @@ func (s *Server) workerLoop(id int) {
 				if opErr, ok := err.(*net.OpError); ok && opErr.Temporary() {
 					continue
 				}
-				fmt.Printf("Error reading from UDP: %v\n", err)
+				fmt.Printf("Error reading from UDP (worker %d): %v\n", id, err)
 				continue
 			}
 
@@ -91,13 +95,14 @@ func (s *Server) workerLoop(id int) {
 }
 
 func (s *Server) handlePacket(data []byte, addr *net.UDPAddr) {
+	if len(data) == 0 {
+		return
+	}
+
 	pt := PacketType(data[0])
 	switch pt {
 	case PacketTypePing:
-		err := s.sendTo([]byte{byte(PacketTypePing)}, addr)
-		if err != nil {
-			return
-		}
+		_ = s.sendTo([]byte{byte(PacketTypePing)}, addr)
 		return
 	case PacketTypeConnect:
 		return
@@ -105,11 +110,9 @@ func (s *Server) handlePacket(data []byte, addr *net.UDPAddr) {
 		return
 	case PacketTypeVoiceData:
 		// todo : déterminer le format du packet
-		//channelID := string(data[1:5])
+		// channelID := string(data[1:5])
 		return
 	default:
 		return
-
 	}
-
 }