Update lint action (#103)

loganmc10 · web-flow · commit 194ad5b64a5b · 2025-03-24T20:37:14.000+01:00
* Update lint action

* Update build.yml

* more
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -17,9 +17,9 @@ jobs:
           cache: false
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v6
+        uses: golangci/golangci-lint-action@v7
         with:
-          args: --timeout=10m --enable-all --disable perfsprint,varnamelen,nlreturn,depguard,wsl,nestif,tagliatelle,goerr113,cyclop,lll,funlen,gocritic,gocognit,gocyclo,exhaustivestruct,exhaustruct,maintidx
+          args: --timeout=10m
 
       - name: Run build script
         run: |
diff --git a/internal/gameServer/server.go b/internal/gameServer/server.go
@@ -106,7 +106,7 @@ func (g *GameServer) ManageBuffer() {
 				}
 			}
 		}
-		time.Sleep(time.Second * 5) //nolint:gomnd,mnd
+		time.Sleep(time.Second * 5)
 	}
 }
 
@@ -125,7 +125,7 @@ func (g *GameServer) ManagePlayers() {
 					playersActive = true
 				} else {
 					g.Logger.Info("play disconnected UDP", "player", i, "regID", g.Registrations[i].RegID, "address", g.GameData.PlayerAddresses[i])
-					g.GameData.Status |= (0x1 << (i + 1)) //nolint:gomnd,mnd
+					g.GameData.Status |= (0x1 << (i + 1))
 
 					g.RegistrationsMutex.Lock() // Registrations can be modified by processTCP
 					delete(g.Registrations, i)
diff --git a/internal/gameServer/tcp.go b/internal/gameServer/tcp.go
@@ -54,8 +54,8 @@ func (g *GameServer) tcpSendFile(tcpData *TCPData, conn *net.TCPConn, withSize b
 			}
 		} else {
 			if withSize {
-				size := make([]byte, 4)                                                     //nolint:gomnd,mnd
-				binary.BigEndian.PutUint32(size, uint32(len(g.TCPFiles[tcpData.Filename]))) //nolint:gosec
+				size := make([]byte, 4)
+				binary.BigEndian.PutUint32(size, uint32(len(g.TCPFiles[tcpData.Filename])))
 				_, err := conn.Write(size)
 				if err != nil {
 					g.Logger.Error(err, "could not write size", "address", conn.RemoteAddr().String())
@@ -123,7 +123,7 @@ func (g *GameServer) tcpSendReg(conn *net.TCPConn) {
 		}
 	}
 	var i byte
-	registrations := make([]byte, 24) //nolint:gomnd,mnd
+	registrations := make([]byte, 24)
 	current := 0
 	for i = range 4 {
 		_, ok := g.Registrations[i]
@@ -146,10 +146,10 @@ func (g *GameServer) tcpSendReg(conn *net.TCPConn) {
 }
 
 func (g *GameServer) processTCP(conn *net.TCPConn) {
-	defer conn.Close()
+	defer conn.Close() //nolint:errcheck
 
 	tcpData := &TCPData{Request: RequestNone}
-	incomingBuffer := make([]byte, 1500) //nolint:gomnd,mnd
+	incomingBuffer := make([]byte, 1500)
 	for {
 		var readDeadline time.Time
 		if tcpData.Buffer.Len() > 0 {
@@ -197,7 +197,7 @@ func (g *GameServer) processTCP(conn *net.TCPConn) {
 		}
 
 		if tcpData.Request == RequestSendSave && tcpData.Filename != "" && tcpData.Filesize == 0 { // get file size from sender
-			if tcpData.Buffer.Len() >= 4 { //nolint:gomnd,mnd
+			if tcpData.Buffer.Len() >= 4 {
 				filesizeBytes := make([]byte, 4)
 				_, err = tcpData.Buffer.Read(filesizeBytes)
 				if err != nil {
@@ -272,14 +272,14 @@ func (g *GameServer) processTCP(conn *net.TCPConn) {
 			if err != nil {
 				g.Logger.Error(err, "TCP error", "address", conn.RemoteAddr().String())
 			}
-			regIDBytes := make([]byte, 4) //nolint:gomnd,mnd
+			regIDBytes := make([]byte, 4)
 			_, err = tcpData.Buffer.Read(regIDBytes)
 			if err != nil {
 				g.Logger.Error(err, "TCP error", "address", conn.RemoteAddr().String())
 			}
 			regID := binary.BigEndian.Uint32(regIDBytes)
 
-			response := make([]byte, 2) //nolint:gomnd,mnd
+			response := make([]byte, 2)
 			_, ok := g.Registrations[playerNumber]
 			if !ok {
 				if playerNumber > 0 && plugin == 2 { // Only P1 can use mempak
@@ -310,7 +310,7 @@ func (g *GameServer) processTCP(conn *net.TCPConn) {
 					response[0] = 0
 				}
 			}
-			response[1] = uint8(g.BufferTarget) //nolint:gosec
+			response[1] = uint8(g.BufferTarget)
 			_, err = conn.Write(response)
 			if err != nil {
 				g.Logger.Error(err, "TCP error", "address", conn.RemoteAddr().String())
@@ -324,7 +324,7 @@ func (g *GameServer) processTCP(conn *net.TCPConn) {
 		}
 
 		if tcpData.Request == RequestDisconnectNotice && tcpData.Buffer.Len() >= 4 { // disconnect notice
-			regIDBytes := make([]byte, 4) //nolint:gomnd,mnd
+			regIDBytes := make([]byte, 4)
 			_, err = tcpData.Buffer.Read(regIDBytes)
 			if err != nil {
 				g.Logger.Error(err, "TCP error", "address", conn.RemoteAddr().String())
@@ -339,7 +339,7 @@ func (g *GameServer) processTCP(conn *net.TCPConn) {
 
 						g.GameDataMutex.Lock() // any player can modify this, which would be in a different thread
 						g.GameData.PlayerAlive[i] = false
-						g.GameData.Status |= (0x1 << (i + 1)) //nolint:gomnd,mnd
+						g.GameData.Status |= (0x1 << (i + 1))
 						g.GameDataMutex.Unlock()
 
 						g.RegistrationsMutex.Lock() // any player can modify this, which would be in a different thread
@@ -361,7 +361,7 @@ func (g *GameServer) processTCP(conn *net.TCPConn) {
 		}
 
 		if tcpData.Request >= RequestSendCustomStart && tcpData.Request < RequestSendCustomStart+CustomDataOffset && tcpData.Buffer.Len() >= 4 && tcpData.CustomID == 0 { // get custom data (for example, plugin settings)
-			dataSizeBytes := make([]byte, 4) //nolint:gomnd,mnd
+			dataSizeBytes := make([]byte, 4)
 			_, err = tcpData.Buffer.Read(dataSizeBytes)
 			if err != nil {
 				g.Logger.Error(err, "TCP error", "address", conn.RemoteAddr().String())
@@ -406,7 +406,7 @@ func (g *GameServer) watchTCP() {
 		remoteAddr, err := net.ResolveTCPAddr(conn.RemoteAddr().Network(), conn.RemoteAddr().String())
 		if err != nil {
 			g.Logger.Error(err, "could not resolve remote IP")
-			conn.Close()
+			conn.Close() //nolint:errcheck
 			continue
 		}
 		for _, v := range g.Players {
@@ -416,7 +416,7 @@ func (g *GameServer) watchTCP() {
 		}
 		if !validated {
 			g.Logger.Error(fmt.Errorf("invalid tcp connection"), "bad IP", "IP", conn.RemoteAddr().String())
-			conn.Close()
+			conn.Close() //nolint:errcheck
 			continue
 		}
 
diff --git a/internal/gameServer/udp.go b/internal/gameServer/udp.go
@@ -50,7 +50,7 @@ const (
 
 // returns true if v is bigger than w (accounting for uint32 wrap around).
 func uintLarger(v uint32, w uint32) bool {
-	return (w - v) > (math.MaxUint32 / 2) //nolint:gomnd,mnd
+	return (w - v) > (math.MaxUint32 / 2)
 }
 
 func (g *GameServer) getPlayerNumberByID(regID uint32) (byte, error) {
@@ -76,7 +76,7 @@ func (g *GameServer) fillInput(playerNumber byte, count uint32) InputData {
 }
 
 func (g *GameServer) sendUDPInput(count uint32, addr *net.UDPAddr, playerNumber byte, spectator bool, sendingPlayerNumber byte) uint32 {
-	buffer := make([]byte, 508) //nolint:gomnd,mnd
+	buffer := make([]byte, 508)
 	var countLag uint32
 	if uintLarger(count, g.GameData.LeadCount) {
 		if !spectator {
@@ -93,7 +93,7 @@ func (g *GameServer) sendUDPInput(count uint32, addr *net.UDPAddr, playerNumber
 	}
 	buffer[1] = playerNumber
 	buffer[2] = g.GameData.Status
-	buffer[3] = uint8(countLag) //nolint:gosec
+	buffer[3] = uint8(countLag)
 	currentByte := 5
 	start := count
 	end := start + g.GameData.BufferSize[sendingPlayerNumber]
@@ -111,7 +111,7 @@ func (g *GameServer) sendUDPInput(count uint32, addr *net.UDPAddr, playerNumber
 	}
 
 	if count > start {
-		buffer[4] = uint8(count - start) //nolint:gosec // number of counts in packet
+		buffer[4] = uint8(count - start) // number of counts in packet
 		_, err := g.UDPListener.WriteToUDP(buffer[0:currentByte], addr)
 		if err != nil {
 			g.Logger.Error(err, "could not send input")
@@ -122,7 +122,8 @@ func (g *GameServer) sendUDPInput(count uint32, addr *net.UDPAddr, playerNumber
 
 func (g *GameServer) processUDP(addr *net.UDPAddr, buf []byte) {
 	playerNumber := buf[1]
-	if buf[0] == KeyInfoClient {
+	switch buf[0] {
+	case KeyInfoClient:
 		g.GameData.PlayerAddresses[playerNumber] = addr
 		count := binary.BigEndian.Uint32(buf[2:])
 
@@ -134,7 +135,7 @@ func (g *GameServer) processUDP(addr *net.UDPAddr, buf []byte) {
 				g.sendUDPInput(count, g.GameData.PlayerAddresses[i], playerNumber, true, NoRegID)
 			}
 		}
-	} else if buf[0] == PlayerInputRequest {
+	case PlayerInputRequest:
 		regID := binary.BigEndian.Uint32(buf[2:])
 		count := binary.BigEndian.Uint32(buf[6:])
 		spectator := buf[10]
@@ -154,7 +155,7 @@ func (g *GameServer) processUDP(addr *net.UDPAddr, buf []byte) {
 		g.GameDataMutex.Unlock()
 
 		g.GameData.CountLag[sendingPlayerNumber] = countLag
-	} else if buf[0] == CP0Info {
+	case CP0Info:
 		if g.GameData.Status&StatusDesync == 0 {
 			viCount := binary.BigEndian.Uint32(buf[1:])
 			syncValue, ok := g.GameData.SyncValues[viCount]
@@ -173,7 +174,7 @@ func (g *GameServer) processUDP(addr *net.UDPAddr, buf []byte) {
 
 func (g *GameServer) watchUDP() {
 	for {
-		buf := make([]byte, 1500) //nolint:gomnd,mnd
+		buf := make([]byte, 1500)
 		_, addr, err := g.UDPListener.ReadFromUDP(buf)
 		if err != nil && !g.isConnClosed(err) {
 			g.Logger.Error(err, "error from UdpListener")
@@ -201,28 +202,28 @@ func (g *GameServer) createUDPServer() error {
 	var err error
 	g.UDPListener, err = net.ListenUDP("udp", &net.UDPAddr{Port: g.Port})
 	if err != nil {
-		return err //nolint:wrapcheck
+		return err
 	}
-	if err := ipv4.NewConn(g.UDPListener).SetTOS(CS4 << 2); err != nil { //nolint:gomnd,mnd
+	if err := ipv4.NewConn(g.UDPListener).SetTOS(CS4 << 2); err != nil {
 		g.Logger.Error(err, "could not set IPv4 DSCP")
 	}
-	if err := ipv6.NewConn(g.UDPListener).SetTrafficClass(CS4 << 2); err != nil { //nolint:gomnd,mnd
+	if err := ipv6.NewConn(g.UDPListener).SetTrafficClass(CS4 << 2); err != nil {
 		g.Logger.Error(err, "could not set IPv6 DSCP")
 	}
 	g.Logger.Info("Created UDP server", "port", g.Port)
 
-	g.GameData.PlayerAddresses = make([]*net.UDPAddr, 4) //nolint:gomnd,mnd
+	g.GameData.PlayerAddresses = make([]*net.UDPAddr, 4)
 	g.GameData.BufferSize = []uint32{3, 3, 3, 3}
 	g.GameData.BufferHealth = []int32{-1, -1, -1, -1}
-	g.GameData.Inputs = make([]*lru.Cache[uint32, InputData], 4) //nolint:gomnd,mnd
+	g.GameData.Inputs = make([]*lru.Cache[uint32, InputData], 4)
 	for i := range 4 {
 		g.GameData.Inputs[i], _ = lru.New[uint32, InputData](InputDataMax)
 	}
-	g.GameData.PendingInput = make([]uint32, 4) //nolint:gomnd,mnd
-	g.GameData.PendingPlugin = make([]byte, 4)  //nolint:gomnd,mnd
+	g.GameData.PendingInput = make([]uint32, 4)
+	g.GameData.PendingPlugin = make([]byte, 4)
 	g.GameData.SyncValues = make(map[uint32][]byte)
-	g.GameData.PlayerAlive = make([]bool, 4) //nolint:gomnd,mnd
-	g.GameData.CountLag = make([]uint32, 4)  //nolint:gomnd,mnd
+	g.GameData.PlayerAlive = make([]bool, 4)
+	g.GameData.CountLag = make([]uint32, 4)
 
 	go g.watchUDP()
 	return nil
diff --git a/internal/lobbyServer/lobby.go b/internal/lobbyServer/lobby.go
@@ -132,7 +132,7 @@ func (s *LobbyServer) updatePlayers(g *gameserver.GameServer) {
 		return
 	}
 	var sendMessage SocketMessage
-	sendMessage.PlayerNames = make([]string, 4) //nolint:gomnd,mnd
+	sendMessage.PlayerNames = make([]string, 4)
 	sendMessage.Type = TypeReplyPlayers
 	for i, v := range g.Players {
 		if v.InLobby {
@@ -194,7 +194,7 @@ func (s *LobbyServer) publishDiscord(message string, channel string) {
 	if err != nil {
 		s.Logger.Error(err, "could not send request")
 	} else {
-		resp.Body.Close()
+		resp.Body.Close() //nolint:errcheck
 	}
 }
 
@@ -231,7 +231,7 @@ func (s *LobbyServer) watchGameServer(name string, g *gameserver.GameServer) {
 			g.PlayersMutex.Unlock()
 			s.updatePlayers(g)
 		}
-		time.Sleep(time.Second * 5) //nolint:gomnd,mnd
+		time.Sleep(time.Second * 5)
 	}
 }
 
@@ -250,7 +250,7 @@ func (s *LobbyServer) validateAuth(receivedMessage SocketMessage) bool {
 
 	timeDifference := now.Sub(receivedTime)
 	absTimeDifference := time.Duration(math.Abs(float64(timeDifference)))
-	maxAllowableDifference := 15 * time.Minute //nolint:gomnd,mnd
+	maxAllowableDifference := 15 * time.Minute
 
 	if absTimeDifference > maxAllowableDifference {
 		s.Logger.Error(fmt.Errorf("clock skew"), "bad time in auth request", "serverTime", now, "clientTime", receivedTime, "emulator", receivedMessage.Emulator)
@@ -271,7 +271,7 @@ func (s *LobbyServer) validateAuth(receivedMessage SocketMessage) bool {
 
 func (s *LobbyServer) wsHandler(ws *websocket.Conn) {
 	authenticated := false
-	defer ws.Close()
+	defer ws.Close() //nolint:errcheck
 
 	// s.Logger.Info("new WS connection", "address", ws.Request().RemoteAddr)
 
@@ -522,7 +522,7 @@ func (s *LobbyServer) wsHandler(ws *websocket.Conn) {
 				} else if g.MD5 != receivedMessage.Room.MD5 {
 					accepted = MismatchVersion
 					message = "ROM does not match room ROM"
-				} else if len(g.Players) >= 4 { //nolint:gomnd,mnd
+				} else if len(g.Players) >= 4 {
 					accepted = RoomFull
 					message = "Room is full"
 				} else if g.Running {
@@ -644,9 +644,9 @@ func (s *LobbyServer) wsHandler(ws *websocket.Conn) {
 							}
 						}
 						if privateNetwork {
-							g.BufferTarget = 1 //nolint:gomnd
+							g.BufferTarget = 1
 						} else {
-							g.BufferTarget = 2 //nolint:gomnd
+							g.BufferTarget = 2
 						}
 					}
 
@@ -693,7 +693,7 @@ func (s *LobbyServer) getOutboundIP(dest *net.UDPAddr) (net.IP, error) {
 	if err != nil {
 		return nil, fmt.Errorf("error creating udp %s", err.Error())
 	}
-	defer conn.Close()
+	defer conn.Close() //nolint:errcheck
 	localAddr, ok := conn.LocalAddr().(*net.UDPAddr)
 	if !ok {
 		return nil, fmt.Errorf("failed to parse address")
@@ -734,11 +734,11 @@ func (s *LobbyServer) runBroadcastServer(broadcastPort int) {
 		s.Logger.Error(err, "could not listen for broadcasts")
 		return
 	}
-	defer broadcastServer.Close()
+	defer broadcastServer.Close() //nolint:errcheck
 
 	s.Logger.Info("listening for broadcasts")
 	for {
-		buf := make([]byte, 1500) //nolint:gomnd,mnd
+		buf := make([]byte, 1500)
 		_, addr, err := broadcastServer.ReadFromUDP(buf)
 		if err != nil {
 			s.Logger.Error(err, "error reading broadcast packet")
@@ -763,7 +763,7 @@ func (s *LobbyServer) RunSocketServer(broadcastPort int) error {
 
 	s.Logger.Info("server running", "address", listenAddress, "version", getVersion(), "platform", runtime.GOOS, "arch", runtime.GOARCH, "goversion", runtime.Version(), "enable-auth", s.EnableAuth)
 
-	err := http.ListenAndServe(listenAddress, nil) //nolint:gosec
+	err := http.ListenAndServe(listenAddress, nil)
 	if err != nil {
 		return fmt.Errorf("error listening on http port %s", err.Error())
 	}
diff --git a/main.go b/main.go
@@ -23,7 +23,7 @@ func newZap(logPath string) (*zap.Logger, error) {
 	if logPath != "" {
 		cfg.OutputPaths = append(cfg.OutputPaths, logPath)
 	}
-	return cfg.Build() //nolint:wrapcheck
+	return cfg.Build()
 }
 
 func main() {
@@ -32,7 +32,7 @@ func main() {
 	disableBroadcast := flag.Bool("disable-broadcast", false, "Disable LAN broadcast")
 	logPath := flag.String("log-path", "", "Write logs to this file")
 	motd := flag.String("motd", "", "MOTD message to display to clients")
-	maxGames := flag.Int("max-games", 10, "Maximum number of concurrent games") //nolint:gomnd,mnd
+	maxGames := flag.Int("max-games", 10, "Maximum number of concurrent games")
 	enableAuth := flag.Bool("enable-auth", false, "Enable client authentication")
 	flag.Parse()
 

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ func (g *GameServer) ManageBuffer() {`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
`109`		`- time.Sleep(time.Second * 5) //nolint:gomnd,mnd`
	`109`	`+ time.Sleep(time.Second * 5)`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`@@ -125,7 +125,7 @@ func (g *GameServer) ManagePlayers() {`
`125`	`125`	`playersActive = true`
`126`	`126`	`} else {`
`127`	`127`	`g.Logger.Info("play disconnected UDP", "player", i, "regID", g.Registrations[i].RegID, "address", g.GameData.PlayerAddresses[i])`
`128`		`- g.GameData.Status \|= (0x1 << (i + 1)) //nolint:gomnd,mnd`
	`128`	`+ g.GameData.Status \|= (0x1 << (i + 1))`
`129`	`129`
`130`	`130`	`g.RegistrationsMutex.Lock() // Registrations can be modified by processTCP`
`131`	`131`	`delete(g.Registrations, i)`