Merge pull request #273 from sdslabs/challengeUpdate

wryonik · web-flow · commit 731280b2e5d2 · 2021-03-02T12:55:13.000+05:30
Add functionality to update challenge at startup and fix authentication error
diff --git a/api/info.go b/api/info.go
@@ -70,9 +70,13 @@ func challengeInfoHandler(c *gin.Context) {
 			return
 		}
 
-		var challSolves int
-		var challengeUser []UserSolveResp
+		challengePorts := make([]uint32, len(challenge.Ports))
+		for index, port := range challenge.Ports {
+			challengePorts[index] = port.PortNo
+		}
 
+		var challSolves int
+		challengeUser := make([]UserSolveResp, 0)
 		for _, user := range users {
 			if user.Role == core.USER_ROLES["contestant"] {
 				userResp := UserSolveResp{
@@ -91,7 +95,7 @@ func challengeInfoHandler(c *gin.Context) {
 			Category:     challenge.Type,
 			CreatedAt:    challenge.CreatedAt,
 			Status:       challenge.Status,
-			Ports:        challenge.Ports,
+			Ports:        challengePorts,
 			Hints:        challenge.Hints,
 			Desc:         challenge.Description,
 			Points:       challenge.Points,
@@ -137,8 +141,13 @@ func availableChallengeInfoHandler(c *gin.Context) {
 				return
 			}
 
+			challengePorts := make([]uint32, len(challenge.Ports))
+			for index, port := range challenge.Ports {
+				challengePorts[index] = port.PortNo
+			}
+
 			var challSolves int
-			var challengeUser []UserSolveResp
+			challengeUser := make([]UserSolveResp, 0)
 
 			for _, user := range users {
 				if user.Role == core.USER_ROLES["contestant"] {
@@ -158,7 +167,7 @@ func availableChallengeInfoHandler(c *gin.Context) {
 				Category:     challenge.Type,
 				CreatedAt:    challenge.CreatedAt,
 				Status:       challenge.Status,
-				Ports:        challenge.Ports,
+				Ports:        challengePorts,
 				Hints:        challenge.Hints,
 				Desc:         challenge.Description,
 				Points:       challenge.Points,
@@ -395,15 +404,15 @@ func userInfoHandler(c *gin.Context) {
 	}
 
 	userChallenges := make([]ChallengeSolveResp, len(challenges))
-	for _, challenge := range challenges {
+	for index, challenge := range challenges {
 		challResp := ChallengeSolveResp{
 			Id:       challenge.ID,
 			Name:     challenge.Name,
 			Category: challenge.Type,
 			SolvedAt: challenge.CreatedAt,
 			Points:   challenge.Points,
 		}
-		userChallenges = append(userChallenges, challResp)
+		userChallenges[index] = challResp
 	}
 
 	rank, err := database.GetUserRank(parsedUserId, user.Score, user.UpdatedAt)
@@ -470,7 +479,7 @@ func submissionsHandler(c *gin.Context) {
 		})
 		return
 	}
-	var submissionsResp []SubmissionResp
+	submissionsResp := make([]SubmissionResp, 0)
 
 	for _, submission := range submissions {
 		user, err := database.QueryUserById(submission.UserID)
diff --git a/api/manage.go b/api/manage.go
@@ -3,6 +3,7 @@ package api
 import (
 	"fmt"
 	"net/http"
+	"os"
 	"path/filepath"
 	"strings"
 	"time"
@@ -360,7 +361,8 @@ func manageScheduledAction(c *gin.Context) {
 
 // Prepare challenge info from .tar file.
 // @Summary Untar and fetch info from beast.toml file in challenge
-// @Description Handles the challenge management from a challenge in tar file
+// @Description Handles the challenge management from a challenge in tar file. Currently prepare the tar file
+// by running `tar cvf chall_dir.tar .` inside the chall_dir.
 // @Tags manage
 // @Accept  json
 // @Produce json
@@ -380,6 +382,14 @@ func manageUploadHandler(c *gin.Context) {
 		return
 	}
 
+	if err = utils.CreateIfNotExistDir(core.BEAST_TEMP_DIR); err != nil {
+		if err := os.MkdirAll(core.BEAST_TEMP_DIR, 0755); err != nil {
+			c.JSON(http.StatusInternalServerError, HTTPErrorResp{
+				Error: fmt.Sprintf("Could not create dir %s: %s", core.BEAST_TEMP_DIR, err),
+			})
+		}
+	}
+
 	tarContextPath := filepath.Join(core.BEAST_TEMP_DIR, file.Filename)
 
 	// The file is received, save it
@@ -436,7 +446,7 @@ func manageUploadHandler(c *gin.Context) {
 
 	c.JSON(http.StatusOK, ChallengePreviewResp{
 		Name:     config.Challenge.Metadata.Name,
-		Category: config.Challenge.Metadata.Tags,
+		Category: config.Challenge.Metadata.Type,
 		Ports:    config.Challenge.Env.Ports,
 		Hints:    config.Challenge.Metadata.Hints,
 		Desc:     config.Challenge.Metadata.Description,
diff --git a/api/response.go b/api/response.go
@@ -2,8 +2,6 @@ package api
 
 import (
 	"time"
-
-	"github.com/sdslabs/beastv4/core/database"
 )
 
 type HTTPPlainResp struct {
@@ -100,7 +98,7 @@ type ChallengeInfoResp struct {
 	Category     string          `json:"category" example:"web"`
 	CreatedAt    time.Time       `json:"createdAt"`
 	Status       string          `json:"status" example:"deployed"`
-	Ports        []database.Port `json:"ports" example:[3001, 3002]`
+	Ports        []uint32        `json:"ports" example:[3001, 3002]`
 	Hints        string          `json:"hints" example:Try robots`
 	Desc         string          `json:"description" example:A simple web challenge`
 	Points       uint            `json:"points" example:"50"`
@@ -110,7 +108,7 @@ type ChallengeInfoResp struct {
 
 type ChallengePreviewResp struct {
 	Name     string   `json:"name" example:"Web Challenge"`
-	Category []string `json:"category" example:"web"`
+	Category string   `json:"category" example:"web"`
 	Ports    []uint32 `json:"ports" example:[3001, 3002]`
 	Hints    []string `json:"hints" example:Try robots`
 	Desc     string   `json:"description" example:A simple web challenge`
diff --git a/api/router.go b/api/router.go
@@ -34,6 +34,10 @@ func initGinRouter() *gin.Engine {
 		authGroup.POST("/reset-password", authorize, resetPasswordHandler)
 	}
 
+	// For serving static files
+	router.StaticFile("/api/info/logo", getLogoPath())
+	router.GET("/api/info/competition-info", competitionInfoHandler)
+
 	// API routes group
 	apiGroup := router.Group("/api", authorize)
 	{
@@ -71,9 +75,6 @@ func initGinRouter() *gin.Engine {
 			infoGroup.POST("/user", userInfoHandler)
 			infoGroup.GET("/user/available", getAllUsersInfoHandler)
 			infoGroup.POST("/submissions", submissionsHandler)
-			infoGroup.GET("/competition-info", competitionInfoHandler)
-			// For serving static files
-			infoGroup.StaticFile("/logo", getLogoPath())
 		}
 
 		// Notification route group
diff --git a/core/database/challenges.go b/core/database/challenges.go
@@ -94,7 +94,7 @@ func QueryAllChallenges() ([]Challenge, error) {
 	DBMux.Lock()
 	defer DBMux.Unlock()
 
-	tx := Db.Find(&challenges)
+	tx := Db.Preload("Ports").Find(&challenges)
 
 	if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
 		return nil, nil
@@ -113,7 +113,7 @@ func QueryChallengeEntries(key string, value string) ([]Challenge, error) {
 	DBMux.Lock()
 	defer DBMux.Unlock()
 
-	tx := Db.Where(queryKey, value).Find(&challenges)
+	tx := Db.Preload("Ports").Where(queryKey, value).Find(&challenges)
 	if errors.Is(tx.Error, gorm.ErrRecordNotFound) {
 		return nil, nil
 	}
diff --git a/core/database/ports.go b/core/database/ports.go
@@ -1,7 +1,6 @@
 package database
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/jinzhu/gorm"
@@ -19,9 +18,7 @@ type Port struct {
 // It returns an error if anything wrong happen during the
 // transaction. If the entry already exists then it does not
 // do anything and returns.
-func PortEntryGetOrCreate(port Port) (Port, error) {
-	var portEntry Port
-
+func PortEntryGetOrCreate(port *Port) (Port, error) {
 	DBMux.Lock()
 	defer DBMux.Unlock()
 
@@ -31,22 +28,13 @@ func PortEntryGetOrCreate(port Port) (Port, error) {
 		return Port{}, fmt.Errorf("Error while starting transaction : %s", tx.Error)
 	}
 
-	err := tx.Where("port_no = ?", port.PortNo).First(&portEntry)
-
-	if !errors.Is(err.Error, gorm.ErrRecordNotFound) {
-		if err := tx.Create(&port).Error; err != nil {
-			tx.Rollback()
-			return Port{}, err
-		}
-
-		return port, tx.Commit().Error
-	}
-
-	if tx.Error != nil {
-		return Port{}, fmt.Errorf("Error while port get for check : %s", tx.Error)
+	err := tx.FirstOrCreate(port, *port).Error
+	if err != nil {
+		tx.Rollback()
+		return Port{}, err
 	}
 
-	return portEntry, tx.Commit().Error
+	return *port, tx.Commit().Error
 }
 
 func GetAllocatedPorts(challenge Challenge) ([]Port, error) {
diff --git a/core/database/user.go b/core/database/user.go
@@ -28,7 +28,7 @@ type User struct {
 
 	Challenges []*Challenge `gorm:"many2many:user_challenges;"`
 	Name       string       `gorm:"not null"`
-	Email      string       `gorm:"non null";unique`
+	Email      string       `gorm:"non null;unique"`
 	SshKey     string
 	Status     uint `gorm:"not null;default:0"` // 0 for unbanned, 1 for banned
 	Score      uint `gorm:"default:0"`
diff --git a/core/manager/challenge.go b/core/manager/challenge.go
@@ -534,18 +534,21 @@ func undeployChallenge(challengeName string, purge bool) error {
 }
 
 func StartUndeployChallenge(challengeName string, purge bool) error {
+	var sendNotificationError error
 	err := undeployChallenge(challengeName, purge)
 	if err != nil {
 		msg := fmt.Sprintf("UNDEPLOY ERROR: %s : %s", challengeName, err)
 		log.Error(msg)
-		notify.SendNotification(notify.Error, msg)
+		sendNotificationError = notify.SendNotification(notify.Error, msg)
 	} else {
 		msg := fmt.Sprintf("UNDEPLOY SUCCESSFUL: %s", challengeName)
 		log.Info(msg)
-		notify.SendNotification(notify.Success, msg)
+		sendNotificationError = notify.SendNotification(notify.Success, msg)
 	}
 
-	log.Info("Notification for the event sent.")
+	if sendNotificationError == nil {
+		log.Info("Notification for the event sent.")
+	}
 	return err
 }
 
diff --git a/core/manager/pipeline.go b/core/manager/pipeline.go
@@ -321,7 +321,7 @@ func bootstrapDeployPipeline(challengeDir string, skipStage bool, skipCommit boo
 	}
 
 	// Using the challenge dir we got, update the database entries for the challenge.
-	err = updateOrCreateChallengeDbEntry(&challenge, config)
+	err = UpdateOrCreateChallengeDbEntry(&challenge, config)
 	if err != nil {
 		log.Errorf("An error occured while creating db entry for challenge :: %s", challengeName)
 		log.Errorf("Db error : %s", err)
@@ -427,14 +427,17 @@ func bootstrapDeployPipeline(challengeDir string, skipStage bool, skipCommit boo
 // notifications to slack on the basis of the result of the deploy pipeline.
 func StartDeployPipeline(challengeDir string, skipStage bool, skipCommit bool) {
 	challengeName := filepath.Base(challengeDir)
+	var sendNotificationError error
 
 	err := bootstrapDeployPipeline(challengeDir, skipStage, skipCommit)
 	if err != nil {
-		notify.SendNotification(notify.Error, err.Error())
+		sendNotificationError = notify.SendNotification(notify.Error, err.Error())
 	} else {
 		msg := fmt.Sprintf("DEPLOY SUCCESS : %s : Challenge deployment pipeline successful.", challengeName)
-		notify.SendNotification(notify.Success, msg)
+		sendNotificationError = notify.SendNotification(notify.Success, msg)
 	}
 
-	log.Debugf("%s: Notification sent", challengeName)
+	if sendNotificationError == nil {
+		log.Debugf("%s: Notification sent", challengeName)
+	}
 }
diff --git a/core/manager/sync.go b/core/manager/sync.go
@@ -69,6 +69,7 @@ func SyncBeastRemote() error {
 	}
 	log.Info("Beast git base synced with remote")
 	go config.UpdateUsedPortList()
+	UpdateChallenges()
 	return fmt.Errorf(strings.Join(errStrings, "\n"))
 }
 
diff --git a/core/manager/utils.go b/core/manager/utils.go
@@ -357,7 +357,7 @@ func copyAdditionalContextToStaging(fileCtx map[string]string, stagingDir string
 }
 
 // TODO: Refactor this.
-func updateOrCreateChallengeDbEntry(challEntry *database.Challenge, config cfg.BeastChallengeConfig) error {
+func UpdateOrCreateChallengeDbEntry(challEntry *database.Challenge, config cfg.BeastChallengeConfig) error {
 	// Challenge is nil, which means the challenge entry does not exist
 	// So create a new challenge entry on the basis of the fields provided
 	// in the config file for the challenge.
@@ -466,7 +466,7 @@ func updateOrCreateChallengeDbEntry(challEntry *database.Challenge, config cfg.B
 			PortNo:      port,
 		}
 
-		gotPort, err := database.PortEntryGetOrCreate(portEntry)
+		gotPort, err := database.PortEntryGetOrCreate(&portEntry)
 		if err != nil {
 			return err
 		}
@@ -676,3 +676,62 @@ func CopyDir(src string, dst string) error {
 	}
 	return nil
 }
+
+func UpdateChallenges() {
+	beastRemoteDir := filepath.Join(core.BEAST_GLOBAL_DIR, core.BEAST_REMOTES_DIR)
+
+	for _, gitRemote := range cfg.Cfg.GitRemotes {
+		if gitRemote.Active != true {
+			continue
+		}
+
+		challengeDir := filepath.Join(beastRemoteDir, gitRemote.RemoteName, core.BEAST_REMOTE_CHALLENGE_DIR)
+		dirs := utils.GetAllDirectoriesName(challengeDir)
+		uploadedChalls := utils.GetAllDirectoriesName(filepath.Join(core.BEAST_GLOBAL_DIR, core.BEAST_UPLOADS_DIR))
+		dirs = append(dirs, uploadedChalls...)
+
+		for _, dir := range dirs {
+
+			configFile := filepath.Join(dir, core.CHALLENGE_CONFIG_FILE_NAME)
+			var config cfg.BeastChallengeConfig
+			_, err := toml.DecodeFile(configFile, &config)
+			if err != nil {
+				log.Errorf("Error while decoding challenge config file")
+				continue
+			}
+			challengeName := config.Challenge.Metadata.Name
+
+			err = config.ValidateRequiredFields(dir)
+			if err != nil {
+				log.Errorf("Error while validating required fields in the challenge directory %s : %s", challengeName, err)
+				continue
+			}
+
+			// Validate challenge directory name with the name of the challenge
+			// provided in the config file for the beast. There should be no
+			// conflict in the name.
+			if challengeName != config.Challenge.Metadata.Name {
+				log.Errorf("Name of the challenge directory(%s) should match the name provided in the config file(%s)",
+					challengeName,
+					config.Challenge.Metadata.Name)
+				continue
+			}
+
+			challenge, err := database.QueryFirstChallengeEntry("name", config.Challenge.Metadata.Name)
+			if err != nil {
+				log.Errorf("Error while querying challenge %s : %s", config.Challenge.Metadata.Name, err)
+				continue
+			}
+
+			// Using the challenge dir we got, update the database entries for the challenge.
+			err = UpdateOrCreateChallengeDbEntry(&challenge, config)
+			if err != nil {
+				log.Errorf("An error occured while creating db entry for challenge :: %s", challengeName)
+				log.Errorf("Db error : %s", err)
+				continue
+			}
+
+		}
+	}
+	log.Debugf("Challenges updated in Db")
+}
diff --git a/core/utils/general.go b/core/utils/general.go
@@ -25,7 +25,7 @@ func GetUser(authHeader string) (string, error) {
 		return "", fmt.Errorf("Not a valid JWT token in authorization header: %s", jwtToken)
 	}
 
-	sDec, err := b64.StdEncoding.DecodeString(userInfoEncr[1])
+	sDec, err := b64.StdEncoding.WithPadding(b64.NoPadding).DecodeString(userInfoEncr[1])
 	if err != nil {
 		return "", fmt.Errorf("Error in decrypting JWT token: %s", err)
 	}
diff --git a/pkg/auth/auth.go b/pkg/auth/auth.go
diff --git a/pkg/notify/main.go b/pkg/notify/main.go

Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,10 @@ func initGinRouter() *gin.Engine {`
`34`	`34`	`authGroup.POST("/reset-password", authorize, resetPasswordHandler)`
`35`	`35`	`}`
`36`	`36`
	`37`	`+ // For serving static files`
	`38`	`+ router.StaticFile("/api/info/logo", getLogoPath())`
	`39`	`+ router.GET("/api/info/competition-info", competitionInfoHandler)`
	`40`	`+`
`37`	`41`	`// API routes group`
`38`	`42`	`apiGroup := router.Group("/api", authorize)`
`39`	`43`	`{`
`@@ -71,9 +75,6 @@ func initGinRouter() *gin.Engine {`
`71`	`75`	`infoGroup.POST("/user", userInfoHandler)`
`72`	`76`	`infoGroup.GET("/user/available", getAllUsersInfoHandler)`
`73`	`77`	`infoGroup.POST("/submissions", submissionsHandler)`
`74`		`- infoGroup.GET("/competition-info", competitionInfoHandler)`
`75`		`- // For serving static files`
`76`		`- infoGroup.StaticFile("/logo", getLogoPath())`
`77`	`78`	`}`
`78`	`79`
`79`	`80`	`// Notification route group`
Original file line number	Diff line number	Diff line change
`@@ -69,6 +69,7 @@ func SyncBeastRemote() error {`
`69`	`69`	`}`
`70`	`70`	`log.Info("Beast git base synced with remote")`
`71`	`71`	`go config.UpdateUsedPortList()`
	`72`	`+ UpdateChallenges()`
`72`	`73`	`return fmt.Errorf(strings.Join(errStrings, "\n"))`
`73`	`74`	`}`
`74`	`75`