add new

argohandler/argohandler.go

@@ -202,6 +202,32 @@ func CreateApp(objectID string, clustername string, ControlPlane string, Platfor
 
 }
 
+func DeleteApp(appName string) error {
+	InitializeClient()
+
+	// Create an application client
+	_, appClient, err := client.NewApplicationClient()
+	if err != nil {
+		log.Fatalf("Failed to create application client: %v", err)
+	}
+
+	cascade := true
+	propagationPolicy := "Foreground"
+
+	_, err = appClient.Delete(context.Background(), &application.ApplicationDeleteRequest{
+		Name:              &appName,
+		Cascade:           &cascade,           // Set to true if you want to delete related resources
+		PropagationPolicy: &propagationPolicy, // You can also use "Background" or "Orphan"
+	})
+
+	if err != nil {
+		return fmt.Errorf("failed to delete application: %v", err)
+	}
+
+	fmt.Printf("Application %s deleted successfully\n", appName)
+	return nil
+}
+
 func getConfig(objectID string, cluster string, namespace string) {
 	var hostcluster HostConfig
 

handler/handler.go

@@ -12,6 +12,7 @@ import (
 	"main/db"
 	"net/http"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -214,6 +215,33 @@ func CreateClusterHandler(w http.ResponseWriter, r *http.Request) {
 
 }
 
+func Deletecluster(w http.ResponseWriter, r *http.Request) {
+
+	clusterName := r.URL.Query().Get("Name")
+	if clusterName == "" {
+		http.Error(w, "Invalid input", http.StatusBadRequest)
+		return
+	}
+
+	err := argohandler.DeleteApp(clusterName)
+	if err != nil {
+		http.Error(w, "File to delete "+clusterName, http.StatusInternalServerError)
+		return
+	}
+
+	res, err := db.Vclusters_details.DeleteOne(context.TODO(), bson.M{"name": clusterName})
+	if err != nil {
+		http.Error(w, `{"message": "Could not delete cluster"}`, http.StatusInternalServerError)
+		return
+	}
+
+	if res.DeletedCount == 0 {
+		http.Error(w, `{"message": "No cluster found to delete"}`, http.StatusNotFound)
+		return
+	}
+
+}
+
 func getClientset(w http.ResponseWriter, clustername string) (*kubernetes.Clientset, *rest.Config, error) {
 
 	kubeconfig, err := getClusterConfig(clustername)
@@ -820,6 +848,15 @@ func Pod_exec(w http.ResponseWriter, r *http.Request) {
 	podName := r.URL.Query().Get("Pod")
 	command := r.URL.Query().Get("Command")
 
+	//var cmd []string
+	parsed, err := strconv.Unquote(command)
+	if err != nil {
+		http.Error(w, "Invalid command string: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+	// cmd = strings.Fields(parsed)
+	cmd := []string{"sh", "-c", parsed}
+
 	if clustername == "" || namespace == "" || podName == "" {
 		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
 		return
@@ -831,8 +868,6 @@ func Pod_exec(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	cmd := []string{command}
-
 	req := clientset.CoreV1().RESTClient().
 		Post().
 		Resource("pods").
@@ -874,3 +909,237 @@ func Pod_exec(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(output)
 }
+
+func Pod_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	podName := r.URL.Query().Get("Pod")
+
+	if clustername == "" || namespace == "" || podName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.CoreV1().Pods(namespace).Delete(context.TODO(), podName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting pod", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(podName + " Has been deleted")
+}
+
+func Service_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	serviceName := r.URL.Query().Get("serviceName")
+
+	if clustername == "" || namespace == "" || serviceName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.CoreV1().Services(namespace).Delete(context.TODO(), serviceName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting service", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(serviceName + " Has been deleted")
+}
+
+func Deployment_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	deploymenteName := r.URL.Query().Get("deploymenteName")
+
+	if clustername == "" || namespace == "" || deploymenteName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.AppsV1().Deployments(namespace).Delete(context.TODO(), deploymenteName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting deploymente", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(deploymenteName + " Has been deleted")
+}
+
+func StatefulSet_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	statefulSetName := r.URL.Query().Get("statefulSetName")
+
+	if clustername == "" || namespace == "" || statefulSetName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.AppsV1().StatefulSets(namespace).Delete(context.TODO(), statefulSetName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting statefulSet", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(statefulSetName + " Has been deleted")
+}
+
+func Daemonsets_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	daemonsetsName := r.URL.Query().Get("daemonsetsName")
+
+	if clustername == "" || namespace == "" || daemonsetsName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.AppsV1().DaemonSets(namespace).Delete(context.TODO(), daemonsetsName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting daemonsets"+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(daemonsetsName + " Has been deleted")
+}
+
+func JobsName_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	jobsName := r.URL.Query().Get("jobsName")
+
+	if clustername == "" || namespace == "" || jobsName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.BatchV1().Jobs(namespace).Delete(context.TODO(), jobsName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting Jobs", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(jobsName + " Has been deleted")
+}
+
+func Replicaset_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	replicasetName := r.URL.Query().Get("replicasetName")
+
+	if clustername == "" || namespace == "" || replicasetName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.AppsV1().ReplicaSets(namespace).Delete(context.TODO(), replicasetName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting ReplicaSets", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(replicasetName + " Has been deleted")
+}
+
+func Replicationcontroller_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	replicationcontrollerName := r.URL.Query().Get("replicationcontrollerName")
+
+	if clustername == "" || namespace == "" || replicationcontrollerName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.CoreV1().ReplicationControllers(namespace).Delete(context.TODO(), replicationcontrollerName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting ReplicationControllers", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(replicationcontrollerName + " Has been deleted")
+}
+
+func Cronjob_delete(w http.ResponseWriter, r *http.Request) {
+	clustername := r.URL.Query().Get("Name")
+	namespace := r.URL.Query().Get("Namespace")
+	cronjobName := r.URL.Query().Get("cronjobName")
+
+	if clustername == "" || namespace == "" || cronjobName == "" {
+		http.Error(w, "Missing required parameters (Name, Namespace, Pod)", http.StatusBadRequest)
+		return
+	}
+
+	clientset, _, err := getClientset(w, clustername)
+	if err != nil {
+		http.Error(w, "Error getting Kubernetes clientset", http.StatusInternalServerError)
+		return
+	}
+
+	err = clientset.BatchV1().CronJobs(namespace).Delete(context.TODO(), cronjobName, metav1.DeleteOptions{})
+	if err != nil {
+		http.Error(w, "Error deleting CronJobs", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(cronjobName + " Has been deleted")
+}

main.go

@@ -126,6 +126,7 @@ func main() {
 	router.HandleFunc("/register", registerHnadler)
 	router.HandleFunc("/login", loginHandler)
 	router.HandleFunc("/createcluster", handler.CreateClusterHandler)
+	router.HandleFunc("/deletecluster", handler.Deletecluster)
 	router.HandleFunc("/clusters", handler.ListUserClusters)
 	router.HandleFunc("/connect", handler.Connect)
 	// router.HandleFunc("/cluster_nodes", handler.Cluster_nodes)
@@ -142,16 +143,33 @@ func main() {
 
 	router.HandleFunc("/pod_logs", handler.Pod_logs)
 	router.HandleFunc("/pod_exec", handler.Pod_exec)
-
+	router.HandleFunc("/pod_delete", handler.Pod_delete)
+	router.HandleFunc("/service_delete", handler.Service_delete)
+	router.HandleFunc("/deployment_delete", handler.Deployment_delete)
+	router.HandleFunc("/statefulSet_delete", handler.StatefulSet_delete)
+	router.HandleFunc("/daemonsets_delete", handler.Daemonsets_delete)
+	router.HandleFunc("/jobsName_delete", handler.JobsName_delete)
+	router.HandleFunc("/replicaset_delete", handler.Replicaset_delete)
+	router.HandleFunc("/replicationcontroller_delete", handler.Replicationcontroller_delete)
+	router.HandleFunc("/cronjob_delete", handler.Cronjob_delete)
 	//handler.RegsiterClusterRoute(router)
 	// Enable CORS
+	// c := cors.New(cors.Options{
+	// 	AllowedOrigins:   []string{"*"}, // Allow all origins
+	// 	AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
+	// 	AllowedHeaders:   []string{"Content-Type", "Authorization", "X-Requested-With", "Accept", "Origin"},
+	// 	ExposedHeaders:   []string{"Content-Length"},
+	// 	AllowCredentials: true,
+	// 	Debug:            true, // Enable debug logging
+	// })
+
 	c := cors.New(cors.Options{
-		AllowedOrigins:   []string{"*"}, // Allow all origins
+		AllowedOrigins:   []string{"*", "http://localhost:4200"}, // frontend origin
 		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
 		AllowedHeaders:   []string{"Content-Type", "Authorization", "X-Requested-With", "Accept", "Origin"},
 		ExposedHeaders:   []string{"Content-Length"},
-		AllowCredentials: true,
+		AllowCredentials: false,
-		Debug:            true, // Enable debug logging
+		Debug:            true,
 	})
 
 	http.ListenAndServe("0.0.0.0:8082", c.Handler(router))