refactor: abstract sandbox interfaces for #13 (#15)

Author: lanmaoxinqing

.pre-commit-config.yaml

@@ -6,6 +6,7 @@ repos:
     rev: v5.0.0
     hooks:
       - id: trailing-whitespace
+        exclude: \.md$|\.rst$
       - id: end-of-file-fixer
       - id: check-yaml
         args: [--allow-multiple-documents]

api-service/controller/env_instance.go

@@ -17,9 +17,9 @@ limitations under the License.
 package controller
 
 import (
+	"api-service/models"
 	backendmodels "envhub/models"
 
-	"api-service/models"
 	"api-service/service"
 	"api-service/util"
 
@@ -29,17 +29,21 @@ import (
 
 // EnvInstanceController handles EnvInstance operations
 type EnvInstanceController struct {
-	scheduleClient *service.ScheduleClient
-	backendClient  *service.BackendClient
-	redisClient    *service.RedisClient
+	envInstanceService service.EnvInstanceService // use interface
+	backendClient      *service.BackendClient
+	redisClient        *service.RedisClient
 }
 
 // NewEnvInstanceController creates a new EnvInstance controller instance
-func NewEnvInstanceController(scheduleClient *service.ScheduleClient, backendClient *service.BackendClient, redisClient *service.RedisClient) *EnvInstanceController {
+func NewEnvInstanceController(
+	envInstanceService service.EnvInstanceService,
+	backendClient *service.BackendClient,
+	redisClient *service.RedisClient,
+) *EnvInstanceController {
 	return &EnvInstanceController{
-		scheduleClient: scheduleClient,
-		backendClient:  backendClient,
-		redisClient:    redisClient,
+		envInstanceService: envInstanceService,
+		backendClient:      backendClient,
+		redisClient:        redisClient,
 	}
 }
 
@@ -52,14 +56,6 @@ type CreateEnvInstanceRequest struct {
 	TTL                  string            `json:"ttl"`
 }
 
-// EnvInstanceResponse represents the response body for EnvInstance operations
-type EnvInstanceResponse struct {
-	ID        string `json:"id"`
-	Env       string `json:"env"`
-	CreatedAt string `json:"createdAt"`
-	Status    string `json:"status"`
-}
-
 // CreateEnvInstance creates a new EnvInstance
 // POST /env-instance/
 func (ctrl *EnvInstanceController) CreateEnvInstance(c *gin.Context) {
@@ -107,7 +103,7 @@ func (ctrl *EnvInstanceController) CreateEnvInstance(c *gin.Context) {
 	// Set TTL for environment
 	backendEnv.DeployConfig["ttl"] = req.TTL
 	// Call ScheduleClient to create Pod
-	envInstance, err := ctrl.scheduleClient.CreatePod(backendEnv)
+	envInstance, err := ctrl.envInstanceService.CreateEnvInstance(backendEnv)
 	if err != nil {
 		backendmodels.JSONErrorWithMessage(c, 500, "Failed to create: "+err.Error())
 		return
@@ -124,30 +120,6 @@ func (ctrl *EnvInstanceController) CreateEnvInstance(c *gin.Context) {
 	backendmodels.JSONSuccess(c, envInstance)
 }
 
-func (ctrl *EnvInstanceController) ListEnvInstances(c *gin.Context) {
-	token := util.GetCurrentToken(c)
-	if token == nil {
-		backendmodels.JSONErrorWithMessage(c, 403, "token required")
-	}
-	var query = models.EnvInstance{Env: &backendmodels.Env{}}
-	id := c.Param("id")
-	if id != "" {
-		// Split name and version using SplitEnvNameVersionStrict function
-		name, version := util.SplitEnvNameVersion(id)
-		query.Env.Name = name
-		query.Env.Version = version
-	}
-	if ctrl.redisClient == nil {
-		backendmodels.JSONErrorWithMessage(c, 500, "no redis is declared for supporting listEnvInstance api, please specify `redis-addr` flag")
-		return
-	}
-	instances, err := ctrl.redisClient.ListEnvInstancesFromRedis(token.Token, &query)
-	if err != nil {
-		backendmodels.JSONErrorWithMessage(c, 500, err.Error())
-	}
-	backendmodels.JSONSuccess(c, instances)
-}
-
 // GetEnvInstance retrieves a single EnvInstance
 // GET /env-instance/:id
 func (ctrl *EnvInstanceController) GetEnvInstance(c *gin.Context) {
@@ -157,7 +129,7 @@ func (ctrl *EnvInstanceController) GetEnvInstance(c *gin.Context) {
 		return
 	}
 	// Call ScheduleClient to query Pod
-	envInstance, err := ctrl.scheduleClient.GetPod(id)
+	envInstance, err := ctrl.envInstanceService.GetEnvInstance(id)
 	if err != nil {
 		backendmodels.JSONErrorWithMessage(c, 500, "Failed to query: "+err.Error())
 		return
@@ -175,16 +147,11 @@ func (ctrl *EnvInstanceController) DeleteEnvInstance(c *gin.Context) {
 	}
 
 	// Call ScheduleClient to delete Pod
-	success, err := ctrl.scheduleClient.DeletePod(id)
+	err := ctrl.envInstanceService.DeleteEnvInstance(id)
 	if err != nil {
 		backendmodels.JSONErrorWithMessage(c, 500, "Failed to delete: "+err.Error())
 		return
 	}
-
-	if !success {
-		backendmodels.JSONErrorWithMessage(c, 500, "Failed to delete")
-		return
-	}
 	backendmodels.JSONSuccess(c, "Deleted successfully")
 	token := util.GetCurrentToken(c)
 	if token != nil && ctrl.redisClient != nil {
@@ -193,3 +160,62 @@ func (ctrl *EnvInstanceController) DeleteEnvInstance(c *gin.Context) {
 		}
 	}
 }
+
+func (ctrl *EnvInstanceController) ListEnvInstances(c *gin.Context) {
+	token := util.GetCurrentToken(c)
+	if token == nil {
+		backendmodels.JSONErrorWithMessage(c, 403, "token required")
+		return
+	}
+	if ctrl.redisClient != nil {
+		var query = models.EnvInstance{Env: &backendmodels.Env{}}
+		id := c.Param("id")
+		if id != "" {
+			name, version := util.SplitEnvNameVersion(id)
+			query.Env.Name = name
+			query.Env.Version = version
+		}
+		instances, err := ctrl.redisClient.ListEnvInstancesFromRedis(token.Token, &query)
+		if err == nil {
+			backendmodels.JSONSuccess(c, instances)
+			return
+		}
+		log.Warnf("failed to list from redis: %v", err)
+	}
+	envName := c.Query("envName")
+	instances, err := ctrl.envInstanceService.ListEnvInstances(envName)
+	if err != nil {
+		backendmodels.JSONErrorWithMessage(c, 500, err.Error())
+		return
+	}
+	backendmodels.JSONSuccess(c, instances)
+}
+
+func (ctrl *EnvInstanceController) Warmup(c *gin.Context) {
+	id := c.Param("id")
+	if id == "" {
+		backendmodels.JSONErrorWithMessage(c, 400, "env id required")
+		return
+	}
+	name, version, err := util.SplitEnvNameVersionStrict(id)
+	if err != nil {
+		backendmodels.JSONErrorWithMessage(c, 400, "invalid env format, should be name@version")
+		return
+	}
+	backendEnv, err := ctrl.backendClient.GetEnvByVersion(name, version)
+	if err != nil {
+		backendmodels.JSONErrorWithMessage(c, 500, "failed to warm up env instance: "+err.Error())
+		return
+	}
+	if backendEnv == nil {
+		backendmodels.JSONErrorWithMessage(c, 404, "can not find env by id: "+id)
+		return
+	}
+
+	err = ctrl.envInstanceService.Warmup(backendEnv)
+	if err != nil {
+		backendmodels.JSONErrorWithMessage(c, 500, err.Error())
+		return
+	}
+	backendmodels.JSONSuccess(c, backendEnv)
+}

api-service/main.go

@@ -34,6 +34,7 @@ import (
 
 var (
 	scheduleAddr  string
+	scheduleType  string
 	backendAddr   string
 	redisAddr     string
 	redisPassword string
@@ -47,6 +48,7 @@ var (
 
 func init() {
 	pflag.StringVar(&scheduleAddr, "schedule-addr", "", "Meta service address (host:port)")
+	pflag.StringVar(&scheduleType, "schedule-type", "k8s", "sandbox service schedule type, currently only 'k8s', 'standard' support")
 	pflag.StringVar(&backendAddr, "backend-addr", "", "backend service address (host:port)")
 
 	pflag.Int64Var(&qps, "qps", int64(100), "total qps limit")
@@ -93,7 +95,15 @@ func main() {
 		log.Fatalf("Failed to create backend client: %v", err)
 	}
 
-	scheduleClient := service.NewScheduleClient(scheduleAddr)
+	var scheduleClient service.EnvInstanceService
+	if scheduleType == "k8s" {
+		scheduleClient = service.NewScheduleClient(scheduleAddr)
+	} else if scheduleType == "standard" {
+		scheduleClient = service.NewEnvInstanceClient(scheduleAddr)
+	} else {
+		log.Fatalf("unsupported schedule type: %v", scheduleType)
+	}
+
 	envInstanceController := controller.NewEnvInstanceController(scheduleClient, backendClient, redisClient)
 	// Main route configuration
 	mainRouter.POST("/env-instance",

api-service/service/cleanup_service.go

@@ -75,48 +75,17 @@ func (cm *AEnvCleanManager) Stop() {
 
 // KubeCleaner cleanup service responsible for periodically cleaning expired EnvInstances
 type KubeCleaner struct {
-	scheduleClient *ScheduleClient
+	scheduleClient EnvInstanceService
 }
 
 // NewCleanupService
-func NewKubeCleaner(scheduleClient *ScheduleClient) *KubeCleaner {
+func NewKubeCleaner(scheduleClient EnvInstanceService) *KubeCleaner {
 	return &KubeCleaner{
 		scheduleClient: scheduleClient,
 	}
 }
 
 // cleanup executes cleanup task
 func (cs *KubeCleaner) cleanup() {
-	log.Println("Starting cleanup task...")
-	// Get all EnvInstances
-	envInstances, err := cs.scheduleClient.FilterPods()
-	if err != nil {
-		log.Printf("Failed to get env instances: %v", err)
-		return
-	}
-	if envInstances == nil || len(*envInstances) == 0 {
-		log.Println("No env instances found")
-		return
-	}
-
-	var deletedCount int
-
-	for _, instance := range *envInstances {
-		// Skip terminated instances
-		if instance.Status == "Terminated" {
-			continue
-		}
-		deleted, err := cs.scheduleClient.DeletePod(instance.ID)
-		if err != nil {
-			log.Printf("Failed to delete instance %s: %v", instance.ID, err)
-			continue
-		}
-		if deleted {
-			deletedCount++
-			log.Printf("Successfully deleted instance %s", instance.ID)
-		} else {
-			log.Printf("Instance %s was not deleted (may already be deleted)", instance.ID)
-		}
-	}
-	log.Printf("Cleanup task completed. Deleted %d expired instances", deletedCount)
+	_ = cs.scheduleClient.Cleanup()
 }