chore: solved go linting issues

lint issues
fordevio · Sep 25, 2024 · e58a2db · e58a2db
1 parent 558eb8f
commit e58a2db
Show file tree

Hide file tree

Showing 23 changed files with 92 additions and 96 deletions.
diff --git a/.golangci.yml b/.golangci.yml
@@ -28,7 +28,6 @@ linters-settings:
     sections:
       - standard
       - default
-      - prefix(github.com/prometheus-operator/prometheus-operator)
   depguard:
     rules:
       forbid-pkg-errors:

diff --git a/cmd/main.go b/cmd/main.go
@@ -31,7 +31,7 @@ func main() {
 
 	api := router.Group("/api/protected")
 	{
-		api.Use(auth.AuthMiddleWare())
+		api.Use(auth.MiddleWare())
 		routes.UserRoutes(api)
 		routes.ContainerRoutes(api)
 		routes.ImageRoutes(api)

diff --git a/conf/cache.go b/conf/cache.go
@@ -2,7 +2,7 @@ package conf
 
 import "github.com/wharf/wharf/pkg/cache"
 
-var Cache *cache.LRUCache = nil
+var Cache *cache.LRUCache
 
 func InitCache() {
 	Cache = cache.New(10)

diff --git a/conf/dir.go b/conf/dir.go
@@ -16,12 +16,10 @@ func InitDir() {
 		err := os.MkdirAll(DirPath, 0755)
 		if err != nil {
 			log.Fatalf("Error creating configuration directory: %s", err)
-			panic(err)
 		}
 		log.Printf("Config directory created: %s", DirPath)
 	} else if err != nil {
 		log.Fatalf("Error checking config directory: %s", err)
-		panic(err)
 	} else {
 		log.Printf("Directory already exists: %s", DirPath)
 	}

diff --git a/internal/controllers/container.go b/internal/controllers/container.go
@@ -28,7 +28,7 @@ func GetContainers() gin.HandlerFunc {
 		errCh := make(chan *errors.Error)
 		containers := []*types.Container{}
 		defer cancel()
-		go dockerContainer.List(conf.DockerClient, ctx, ch, errCh)
+		go dockerContainer.List(ctx, conf.DockerClient, ch, errCh)
 		for err := range errCh {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Err})
@@ -56,7 +56,7 @@ func StopContainer() gin.HandlerFunc {
 		}
 		errCh := make(chan *errors.Error)
 
-		go dockerContainer.Stop(conf.DockerClient, ctx, id, errCh)
+		go dockerContainer.Stop(ctx, conf.DockerClient, id, errCh)
 		for err := range errCh {
 			if err != nil {
 				log.Println(err)
@@ -80,7 +80,7 @@ func UnpauseContainer() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid permissions"})
 			return
 		}
-		err := dockerContainer.Unpause(conf.DockerClient, ctx, id)
+		err := dockerContainer.Unpause(ctx, conf.DockerClient, id)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -131,7 +131,7 @@ func RemoveContainer() gin.HandlerFunc {
 		if requestBody.RemoveVolumes != nil {
 			opts.RemoveVolumes = *requestBody.RemoveVolumes
 		}
-		err := dockerContainer.Remove(conf.DockerClient, ctx, id, opts)
+		err := dockerContainer.Remove(ctx, conf.DockerClient, id, opts)
 
 		if err != nil {
 			if errdefs.IsNotFound(err) {
@@ -157,7 +157,7 @@ func PruneContainers() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid permissions"})
 			return
 		}
-		report, err := dockerContainer.Prune(conf.DockerClient, ctx)
+		report, err := dockerContainer.Prune(ctx, conf.DockerClient)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -173,7 +173,7 @@ func ContainerStats() gin.HandlerFunc {
 		var ctx, cancel = context.WithTimeout(context.Background(), 100*time.Second)
 		id := c.Param("id")
 		defer cancel()
-		body, err := dockerContainer.Stats(conf.DockerClient, ctx, id)
+		body, err := dockerContainer.Stats(ctx, conf.DockerClient, id)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -203,7 +203,7 @@ func ContainerLogs() gin.HandlerFunc {
 			return
 		}
 
-		body, err := dockerContainer.Logs(conf.DockerClient, ctx, id, days)
+		body, err := dockerContainer.Logs(ctx, conf.DockerClient, id, days)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -242,7 +242,7 @@ func ContainerRename() gin.HandlerFunc {
 			return
 		}
 
-		err := dockerContainer.Rename(conf.DockerClient, ctx, id, requestBody.NewName)
+		err := dockerContainer.Rename(ctx, conf.DockerClient, id, requestBody.NewName)
 
 		if err != nil {
 			if errdefs.IsNotFound(err) {
@@ -340,7 +340,7 @@ func ContainerCreate() gin.HandlerFunc {
 			hostConfig.PortBindings = pmap
 		}
 
-		res, err := dockerContainer.Create(conf.DockerClient, ctx, &config, &hostConfig, requestBody.Name)
+		res, err := dockerContainer.Create(ctx, conf.DockerClient, &config, &hostConfig, requestBody.Name)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -363,7 +363,7 @@ func ContainerPause() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid permissions"})
 			return
 		}
-		err := dockerContainer.Pause(conf.DockerClient, ctx, id)
+		err := dockerContainer.Pause(ctx, conf.DockerClient, id)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -389,7 +389,7 @@ func ContainerStart() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid permissions"})
 			return
 		}
-		err := dockerContainer.Start(conf.DockerClient, ctx, id)
+		err := dockerContainer.Start(ctx, conf.DockerClient, id)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})

diff --git a/internal/controllers/image.go b/internal/controllers/image.go
@@ -23,7 +23,7 @@ func GetImages() gin.HandlerFunc {
 		errCh := make(chan *errors.Error)
 		images := []*image.Summary{}
 		defer cancel()
-		go dockerImage.GetAll(conf.DockerClient, ctx, ch, errCh)
+		go dockerImage.GetAll(ctx, conf.DockerClient, ch, errCh)
 		for err := range errCh {
 			log.Println(err)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Err})
@@ -47,7 +47,7 @@ func PruneImages() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid premissions"})
 			return
 		}
-		report, err := dockerImage.Prune(conf.DockerClient, ctx)
+		report, err := dockerImage.Prune(ctx, conf.DockerClient)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -88,7 +88,7 @@ func RemoveImage() gin.HandlerFunc {
 		if requestBody.PruneChildren != nil {
 			opts.PruneChildren = *requestBody.PruneChildren
 		}
-		report, err := dockerImage.Remove(conf.DockerClient, ctx, id, opts)
+		report, err := dockerImage.Remove(ctx, conf.DockerClient, id, opts)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -127,7 +127,7 @@ func TagImage() gin.HandlerFunc {
 			return
 		}
 
-		err := dockerImage.Tag(conf.DockerClient, ctx, id, reqBody.Tag)
+		err := dockerImage.Tag(ctx, conf.DockerClient, id, reqBody.Tag)
 
 		if err != nil {
 			if errdefs.IsNotFound(err) {

diff --git a/internal/controllers/network.go b/internal/controllers/network.go
@@ -24,7 +24,7 @@ func GetNetworks() gin.HandlerFunc {
 		errCh := make(chan *errors.Error)
 		networks := []*types.NetworkResource{}
 		defer cancel()
-		go dockerNetwork.GetAll(conf.DockerClient, ctx, ch, errCh)
+		go dockerNetwork.GetAll(ctx, conf.DockerClient, ch, errCh)
 		for err := range errCh {
 			log.Println(err)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Err})
@@ -47,7 +47,7 @@ func PruneNetwork() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid permissions"})
 			return
 		}
-		report, err := dockerNetwork.Prune(conf.DockerClient, ctx)
+		report, err := dockerNetwork.Prune(ctx, conf.DockerClient)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -68,7 +68,7 @@ func RemoveNetwork() gin.HandlerFunc {
 			return
 		}
 		id := c.Param("id")
-		err := dockerNetwork.Remove(conf.DockerClient, ctx, id)
+		err := dockerNetwork.Remove(ctx, conf.DockerClient, id)
 		if err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -113,7 +113,7 @@ func DisconnectNetwork() gin.HandlerFunc {
 			forceDisconnect = *reqBody.Force
 		}
 
-		err := dockerNetwork.Disconnect(conf.DockerClient, ctx, id, reqBody.ContainerID, forceDisconnect)
+		err := dockerNetwork.Disconnect(ctx, conf.DockerClient, id, reqBody.ContainerID, forceDisconnect)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -153,7 +153,7 @@ func ConnectNetwork() gin.HandlerFunc {
 			return
 		}
 
-		err := dockerNetwork.Connect(conf.DockerClient, ctx, id, reqBody.ContainerID)
+		err := dockerNetwork.Connect(ctx, conf.DockerClient, id, reqBody.ContainerID)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -198,7 +198,7 @@ func CreateNetwork() gin.HandlerFunc {
 			CheckDuplicate: true,
 		}
 
-		res, err := dockerNetwork.Create(conf.DockerClient, ctx, reqBody.Name, options)
+		res, err := dockerNetwork.Create(ctx, conf.DockerClient, reqBody.Name, options)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})

diff --git a/internal/controllers/user.go b/internal/controllers/user.go
@@ -118,7 +118,7 @@ func UpdateUser() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Request not sent by admin"})
 			return
 		}
-		isUser, err := store.GetUserById(id)
+		isUser, err := store.GetUserByID(id)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
@@ -176,7 +176,7 @@ func DeleteUser() gin.HandlerFunc {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "Request not sent by admin"})
 			return
 		}
-		isUser, err := store.GetUserById(id)
+		isUser, err := store.GetUserByID(id)
 		if err != nil {
 			log.Println(err)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
@@ -233,7 +233,7 @@ func GetUser() gin.HandlerFunc {
 			Username:   *reqUser.Username,
 			Permission: reqUser.Permission,
 			IsAdmin:    reqUser.IsAdmin,
-			Id:         reqUser.ID,
+			ID:         reqUser.ID,
 		}
 		c.JSON(http.StatusOK, res)
 	}

diff --git a/internal/controllers/volume.go b/internal/controllers/volume.go
@@ -23,7 +23,7 @@ func GetVolumes() gin.HandlerFunc {
 		errCh := make(chan *errors.Error)
 		volumes := []*volume.Volume{}
 		defer cancel()
-		go dockerVolume.GetAll(conf.DockerClient, ctx, ch, errCh)
+		go dockerVolume.GetAll(ctx, conf.DockerClient, ch, errCh)
 		for err := range errCh {
 			log.Println(err.Err)
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Err})
@@ -59,7 +59,7 @@ func RemoveVolume() gin.HandlerFunc {
 		if reqBody.Force != nil {
 			forceRem = *reqBody.Force
 		}
-		if err := dockerVolume.Remove(conf.DockerClient, ctx, id, forceRem); err != nil {
+		if err := dockerVolume.Remove(ctx, conf.DockerClient, id, forceRem); err != nil {
 			if errdefs.IsNotFound(err) {
 				c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
 				return
@@ -85,7 +85,7 @@ func PruneVolumes() gin.HandlerFunc {
 			return
 		}
 
-		report, err := dockerVolume.Prune(conf.DockerClient, ctx)
+		report, err := dockerVolume.Prune(ctx, conf.DockerClient)
 		if err != nil {
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
 			return
@@ -125,7 +125,7 @@ func CreateVolume() gin.HandlerFunc {
 			opts.Labels = *createVolumeRequest.Labels
 		}
 
-		vol, err := dockerVolume.Create(conf.DockerClient, ctx, opts)
+		vol, err := dockerVolume.Create(ctx, conf.DockerClient, opts)
 		if err != nil {
 			c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
 			return

diff --git a/pkg/auth/auth.go b/pkg/auth/auth.go
@@ -27,7 +27,7 @@ func PasswordValidation(fl validator.FieldLevel) bool {
 	return letter(password) && number(password)
 }
 
-func AuthMiddleWare() gin.HandlerFunc {
+func MiddleWare() gin.HandlerFunc {
 	return func(c *gin.Context) {
 		clientToken := c.Request.Header.Get("token")
 		if clientToken == "" {
@@ -54,7 +54,7 @@ func AuthMiddleWare() gin.HandlerFunc {
 				}
 			}
 		}
-		user, err := store.GetUserById(uid)
+		user, err := store.GetUserByID(uid)
 		if err != nil {
 			c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
 			c.Abort()

diff --git a/pkg/auth/jwt.go b/pkg/auth/jwt.go
@@ -9,9 +9,9 @@ import (
 
 var secretKey = []byte("secret-key")
 
-func GenerateToken(userId int) (*string, error) {
+func GenerateToken(userID int) (*string, error) {
 	claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
-		"sub": userId,                                // Subject (user identifier)
+		"sub": userID,                                // Subject (user identifier)
 		"iss": "wharf",                               // Issuer// Audience (user role)
 		"exp": time.Now().Add(time.Hour * 10).Unix(), // Expiration time = 10Hr
 		"iat": time.Now().Unix(),                     // Issued at
@@ -24,7 +24,7 @@ func GenerateToken(userId int) (*string, error) {
 }
 
 func VerifyToken(tokenString string) (jwt.MapClaims, error) {
-	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+	token, err := jwt.Parse(tokenString, func(_ *jwt.Token) (interface{}, error) {
 		return secretKey, nil
 	})
 	if err != nil {
@@ -35,8 +35,6 @@ func VerifyToken(tokenString string) (jwt.MapClaims, error) {
 	}
 	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
 		return claims, nil
-
-	} else {
-		return nil, fmt.Errorf("invalid token")
 	}
+	return nil, fmt.Errorf("invalid token")
 }
diff --git a/pkg/cache/list.go b/pkg/cache/list.go
@@ -38,9 +38,8 @@ func (l *DoublyLinkedList) Remove(node *Node) *Node {
 		l.len--
 	}()
 
-	tail := l.root.prev
-	l.isolate(tail)
-	return tail
+	l.isolate(node)
+	return node
 }
 
 func (l *DoublyLinkedList) isolate(node *Node) {

diff --git a/pkg/cache/lrucache.go b/pkg/cache/lrucache.go
@@ -60,7 +60,7 @@ func (l *LRUCache) Invalidate(key string) {
 	if !exists {
 		return
 	}
-	l.list.Remove(node)
+	l.list.isolate(node)
 	delete(l.items, key)
 }