katana-cli [WIP]

cliHelpers/chalDeployerService/deleteChal.go

@@ -0,0 +1,32 @@
+package chalDeployerService
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/spf13/cobra"
+
+	g "github.com/sdslabs/katana/configs"
+)
+
+// still have to test this [WIP]
+
+var DelChalCmd = &cobra.Command{
+	Use:   "delete-chal",
+	Short: "Run the Challenge Delete command",
+	Long:  "Deletes the Challenge",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		challengeID := args[0]
+		g.LoadConfiguration();
+		g.LoadKubeElements();
+
+		if err := DeleteChallenge(challengeID); err != nil {
+			log.Printf("Error deleting the challenge with ID %s: %v", challengeID, err)
+			return fmt.Errorf("failed to delete challenge: %v", err)
+		}
+
+		log.Printf("Challenge with ID %s deleted successfully", challengeID)
+		return nil
+	},
+}

cliHelpers/chalDeployerService/deployChal.go

@@ -0,0 +1,27 @@
+package chalDeployerService
+
+import (
+	"log"
+
+	"github.com/spf13/cobra"
+
+	g "github.com/sdslabs/katana/configs"
+)
+
+// still have to test this [WIP]
+
+var DeployChalCmd = &cobra.Command{
+	Use:   "chal-deploy",
+	Short: "Run the Challenge Deploy command",
+	Long:  "Runs the challenge deploy",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		g.LoadConfiguration();
+		g.LoadKubeElements();
+		if err := DeployChallenge(); err != nil {
+			log.Println("Error deploying the challenge:", err)
+			return err
+		}
+		log.Println("Challenge deployed successfully")
+		return nil
+	},
+}

cliHelpers/chalDeployerService/helper.go

@@ -0,0 +1,191 @@
+package chalDeployerService
+
+import (
+	"context"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/sdslabs/katana/configs"
+	g "github.com/sdslabs/katana/configs"
+	"github.com/sdslabs/katana/lib/deployment"
+	"github.com/sdslabs/katana/lib/utils"
+	"github.com/sdslabs/katana/services/challengedeployerservice"
+)
+
+func DeployChallenge() error {
+	patch := false
+	replicas := int32(1)
+	challengeType := "web"
+	log.Println("Starting")
+
+	katanaDir, err := utils.GetKatanaRootPath()
+	if err != nil {
+		return err
+	}
+	challengesDir:=katanaDir+"/challenges"	
+
+	//Read folder challenge by os
+	dir, err := os.Open(challengesDir)
+
+	//Loop over all subfolders in the challenge folder
+	if err != nil {
+		log.Println("Error in opening challenges folder")
+		return err
+	}
+	defer dir.Close()
+
+	//Read all challenges in the folder
+	fileInfos, err := dir.Readdir(-1)
+	if err != nil {
+		log.Println("Error in reading challenges folder")
+		return err
+	}
+
+	res := make([][]string, 0)
+
+	//Loop over all folders
+	for _, fileInfo := range fileInfos {
+		//Check if it is a directory
+		if fileInfo.IsDir() {
+			//Get the challenger name
+			folderName := fileInfo.Name()
+			log.Println("Folder name is : " + folderName)
+			//Update challenge path to be absolute path
+			challengePath, _ := os.Getwd()
+			challengePath = challengePath + "/challenges/" + folderName
+			log.Println("Challenge path is : " + challengePath)
+			log.Println(challengePath + "/" + folderName + "/" + folderName)
+
+			//Check if the folder has a Dockerfile
+			if _, err := os.Stat(challengePath + "/" + folderName + "/" + folderName); err != nil {
+				log.Println("Dockerfile not found in the " + folderName + " challenge folder. Please follow proper format.")
+			} else {
+				//Update challenge path to get dockerfile
+				err := utils.BuildDockerImage(folderName, challengePath+"/"+folderName+"/"+folderName)
+				if err != nil {
+					return err
+				}
+				clusterConfig := g.ClusterConfig
+				numberOfTeams := clusterConfig.TeamCount
+				for i := 0; i < int(numberOfTeams); i++ {
+					log.Println("-----------Deploying challenge for team: " + strconv.Itoa(i) + " --------")
+					teamName := "katana-team-" + strconv.Itoa(i)
+					err = deployment.DeployChallengeToCluster(folderName, teamName, patch, replicas)
+					if err != nil {
+						if !(strings.Contains(err.Error(), "already exists")) {
+							return err
+						}else{
+							log.Println("Deployment already existed.")
+						}
+					}
+					url, err := challengedeployerservice.CreateServiceForChallenge(folderName, teamName, 3000, i)
+					if err != nil {
+						return err
+					} else {
+						res = append(res, []string{teamName, url})
+					}
+				}
+			}
+			err = challengedeployerservice.CopyChallengeIntoTsuka(challengePath, folderName, challengeType)
+			if err != nil {
+				return err
+			}
+			err = challengedeployerservice.CopyFlagDataIntoKashira(challengePath, folderName)
+			if err != nil {
+				return err
+			}
+			err = challengedeployerservice.CopyChallengeCheckerIntoKissaki(challengePath, folderName)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func DeleteChallenge(challengeName string) error {
+
+	//Delete chall directory also ?
+	log.Println("Challenge name is : " + challengeName)
+
+	dirPath, _ := os.Getwd()
+	challengePath := dirPath + "/challenges/" + challengeName
+	log.Println("Deleting challenge folder :", challengePath)
+	err := os.RemoveAll(challengePath)
+	if err != nil {
+		log.Println("Error in deleting challenge folder")
+		return err
+	}
+
+	totalTeams := utils.GetTeamNumber()
+
+	for i := 0; i < totalTeams; i++ {
+
+		teamName := "team-" + strconv.Itoa(i)
+
+		teamNamespace := "katana-" + teamName + "-ns"
+		kubeclient := configs.GlobalKubeClient
+		if err != nil {
+			return err
+		}
+
+		log.Println("---------------Deleting challenge for team: ", teamNamespace)
+		serviceClient := kubeclient.CoreV1().Services(teamNamespace)
+		deploymentsClient := kubeclient.AppsV1().Deployments(teamNamespace)
+
+		//Get deployment
+		deps, err := deploymentsClient.Get(context.TODO(), challengeName, metav1.GetOptions{})
+		if err != nil {
+			log.Println(" Error in getting deployments associated with the challenge. ")
+			continue
+		}
+
+		//Delete deployments
+		if deps.Name != challengeName {
+			log.Println("Deployment does not exist. Create one using /deploy route.")
+			return nil
+		} else {
+			log.Println("Deleting deployment...")
+			deletePolicy := metav1.DeletePropagationForeground
+			err = deploymentsClient.Delete(context.TODO(), challengeName, metav1.DeleteOptions{PropagationPolicy: &deletePolicy})
+			if err != nil {
+				log.Println("Error in deleting deployment.")
+				continue
+			}
+		}
+
+		//Check if service exists
+		services, err := serviceClient.List(context.TODO(), metav1.ListOptions{})
+		if err != nil {
+			log.Println(" Error in getting services for" + challengeName + "in the namespace " + teamNamespace)
+			return err
+		}
+
+		flag := 0
+		for _, service := range services.Items {
+			if service.Name == challengeName+"-svc-"+strconv.Itoa(i) {
+				flag = 1
+			}
+		}
+		if flag == 0 {
+			log.Println("Service does not exist for the " + challengeName + " in namespace " + teamNamespace)
+			continue
+		}
+
+		//Delete service
+		log.Println("Deleting services associated with this challenge...")
+		err = serviceClient.Delete(context.TODO(), challengeName+"-svc-"+strconv.Itoa(i), metav1.DeleteOptions{})
+		if err != nil {
+			log.Println("Error in deleting service for "+challengeName+" in namespace "+teamNamespace, err)
+			continue
+		}
+	}
+
+	log.Println("Process completed")
+
+	return nil
+}

cliHelpers/createTeams.go

@@ -0,0 +1,112 @@
+package cliHelpers
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"html/template"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	coreV1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/sdslabs/katana/configs"
+	"github.com/sdslabs/katana/lib/deployment"
+	"github.com/sdslabs/katana/lib/mongo"
+	"github.com/sdslabs/katana/lib/utils"
+	"github.com/sdslabs/katana/services/infrasetservice"
+)
+
+func CreateTeams() error {
+
+	// if !utils.VerifyToken(c) {
+	// 	return c.SendString("Unauthorized")
+	// }
+	config:= configs.GlobalKubeConfig
+	client:= configs.GlobalKubeClient
+	noOfTeams := int(configs.ClusterConfig.TeamCount)
+
+	if _, err := os.Stat("teams"); os.IsNotExist(err) {
+		errDir := os.Mkdir("teams", 0755)
+		if errDir != nil {
+			log.Fatal(err)
+			return err
+		}
+	}
+
+	// Create a directory named teams in the current directory
+	if _, err := os.Stat("teams"); os.IsNotExist(err) {
+		errDir := os.Mkdir("teams", 0755)
+		if errDir != nil {
+			log.Fatal(err)
+		}
+	}
+
+	// Create a directory named teams in the current directory
+	if _, err := os.Stat("teams"); os.IsNotExist(err) {
+		errDir := os.Mkdir("teams", 0755)
+		if errDir != nil {
+			log.Fatal(err)
+		}
+	}
+
+	var teams []interface{}
+	credsFile, err := os.Create(configs.SSHProviderConfig.CredsFile)
+	if err != nil {
+		log.Fatal(err)
+		return err
+	}
+
+	for i := 0; i < noOfTeams; i++ {
+		// Create a directory named katana-team-i in the teams directory
+		if _, err := os.Stat("teams/katana-team-" + strconv.Itoa(i)); os.IsNotExist(err) {
+			errDir := os.Mkdir("teams/katana-team-"+strconv.Itoa(i), 0755)
+			if errDir != nil {
+				log.Fatal(err)
+				return err
+			}
+		}
+
+		log.Println("Creating Team: " + strconv.Itoa(i))
+		namespace := "katana-team-" + strconv.Itoa(i) + "-ns"
+		nsName := &coreV1.Namespace{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: namespace,
+			},
+		}
+		_, err = client.CoreV1().Namespaces().Create(context.TODO(), nsName, metav1.CreateOptions{})
+		if err != nil {
+			log.Fatal(err)
+			return err
+		}
+
+		manifest := &bytes.Buffer{}
+		tmpl, err := template.ParseFiles(filepath.Join(configs.ClusterConfig.TemplatedManifestDir, "runtime", "teams.yml"))
+		if err != nil {
+			return err
+		}
+
+		pwd, team, err := infrasetservice.CreateTeamCredentials(i)
+		if err != nil {
+			return err
+		}
+		deploymentConfig := utils.DeploymentConfig()
+
+		deploymentConfig.SSHPassword = pwd
+
+		if err = tmpl.Execute(manifest, deploymentConfig); err != nil {
+			return err
+		}
+
+		if err = deployment.ApplyManifest(config, client, manifest.Bytes(), namespace); err != nil {
+			return err
+		}
+		teams = append(teams, team)
+		fmt.Fprintf(credsFile, "Team: %d, Username: %s, Password: %s\n", i, team.Name, pwd)
+	}
+	mongo.CreateTeams(teams)
+	return nil
+}