implement read/write protection and resource limits to C code executor

Author: Anga205

config/globals.go

@@ -4,10 +4,13 @@ import "github.com/caarlos0/env/v11"
 
 type globals struct {
 	RAM_LIMIT           uint `env:"GLOBAL_RAM_LIMIT" envDefault:"1048576"` // 1 GB by default (or 1048576 KB), this is the total amount of RAM that can be used by all running sandboxes at any given time
-	ENABLE_QUEUE        bool `env:"ENABLE_QUEUE" envDefault:"true"`        // if false, the server will reject requests when ram limit is reached, if true, the server will queue requests until sufficient ram is available
+	ENABLE_QUEUE        bool `env:"ENABLE_QUEUE" envDefault:"false"`       // if false, the server will reject requests when ram limit is reached, if true, the server will queue requests until sufficient ram is available
 	ENABLE_DEBUG_ROUTES bool `env:"ENABLE_DEBUG" envDefault:"false"`       // if true, the server will expose debug routes for monitoring and debugging purposes
 }
 
+// i know the docs say that queueing is true by default
+// ill set it to false by default for now because queueing is not implemented yet
+
 func (cfg *globals) load() error {
 	return env.Parse(cfg)
 }

dispatcher/dispatch.go

@@ -2,21 +2,14 @@ package dispatcher
 
 import (
 	"CodeSandboxAPI/config"
+	"CodeSandboxAPI/executor"
 	"CodeSandboxAPI/models"
+	"CodeSandboxAPI/resourcemanager"
 	"fmt"
-	"time"
-
-	"github.com/gin-gonic/gin"
 )
 
-func CallDispatcher(c *gin.Context) {
-	var req models.Request
-	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(400, gin.H{"error": "Invalid request format"})
-		return
-	}
+func Dispatch(req models.Request) (models.Response, error) {
 
-	req.Timeout *= time.Second // Convert seconds to duration
 	if req.Timeout == 0 {
 		req.Timeout = config.Config.Limits.DefaultTimeout
 	} else if req.Timeout > config.Config.Limits.MaxTimeout {
@@ -28,12 +21,22 @@ func CallDispatcher(c *gin.Context) {
 	} else if req.MemoryLimit > config.Config.Limits.MaxMemoryLimit {
 		req.MemoryLimit = config.Config.Limits.MaxMemoryLimit
 	}
-
-	resp, err := dispatch(req)
-	if err != nil {
-		fmt.Printf("Error during dispatch: %v\n", err)
-		c.JSON(500, gin.H{"error": "Internal server error"})
-		return
+	if !config.Config.Globals.ENABLE_QUEUE {
+		if !resourcemanager.ReserveRAM(req.MemoryLimit) { // TODO: handle condition for queueing requests when RAM is not available
+			return models.Response{
+				Stdout:        "",
+				Stderr:        "Resource limit reached, please try again later",
+				ExecutionTime: 0,
+			}, fmt.Errorf("Failed to reserve RAM")
+		}
+		defer resourcemanager.ReleaseRAM(req.MemoryLimit)
+		return executor.Execute(req)
+	} else {
+		// TODO: Implement queueing logic
+		return models.Response{
+			Stdout:        "",
+			Stderr:        "Queueing is not implemented yet",
+			ExecutionTime: 0,
+		}, nil
 	}
-	c.JSON(200, resp)
 }

dispatcher/main.go

@@ -67,7 +67,7 @@ func Execute(req models.Request) (models.Response, error) {
 		Setpgid:    true,
 	}
 	if len(req.Stdin) > 0 {
-		runCmd.Stdin = strings.NewReader(strings.Join(req.Stdin, "\n"))
+		runCmd.Stdin = strings.NewReader(req.Stdin)
 	}
 
 	var stdoutBuf strings.Builder

executor/main.go

@@ -1,18 +1,56 @@
 package models
 
-import "time"
+import (
+	"fmt"
+	"strings"
+	"time"
+)
 
 type Request struct {
 	Language    string        `json:"language"`         // Programming language (e.g., "c", "python", "javascript")
 	Code        string        `json:"code"`             // Source code to execute
-	Timeout     time.Duration `json:"timeout"`          // time limit in seconds
+	Timeout     time.Duration `json:"timeout"`          // time limit in nanoseconds
 	MemoryLimit uint          `json:"max_memory"`       // memory limit in KB
-	Stdin       []string      `json:"inputs,omitempty"` // Array of strings for multiple lines of input, optional
+	Stdin       string        `json:"inputs,omitempty"` // input to take from STDIN, optional, can be multiple lines of input
+}
+
+type SimpleRequest struct {
+	Language    string   `json:"language"`         // Programming language (e.g., "c", "python", "javascript")
+	Code        string   `json:"code"`             // Source code to execute
+	Timeout     uint     `json:"timeout"`          // time limit in seconds
+	MemoryLimit uint     `json:"max_memory"`       // memory limit in KB
+	Stdin       []string `json:"inputs,omitempty"` // Array of strings for multiple lines of input, optional
+}
+
+func (sr *SimpleRequest) ToRequest() Request {
+	return Request{
+		Language:    sr.Language,
+		Code:        sr.Code,
+		Timeout:     time.Duration(sr.Timeout) * time.Second,
+		MemoryLimit: sr.MemoryLimit,
+		Stdin:       strings.Join(sr.Stdin, "\n"),
+	}
 }
 
 type Response struct {
 	Stdout        string        `json:"output"`
 	Stderr        string        `json:"error"`
-	ExecutionTime time.Duration `json:"cpu_time"`
-	MemoryUsed    uint          `json:"memory_used"`
+	ExecutionTime time.Duration `json:"cpu_time"`    // CPU time used by the program in nanoseconds
+	MemoryUsed    uint          `json:"memory_used"` // Peak memory used by the program in KB
+}
+
+type SimpleResponse struct {
+	Stdout        string `json:"output"`
+	Stderr        string `json:"error"`
+	MemoryUsed    string `json:"memory_used"` // Peak memory used by the program in KB
+	ExecutionTime string `json:"cpu_time"`    // CPU time used by the program in seconds (ends in s, e.g., "0.5s")
+}
+
+func (r *Response) ToSimpleResponse() SimpleResponse {
+	return SimpleResponse{
+		Stdout:        r.Stdout,
+		Stderr:        r.Stderr,
+		ExecutionTime: r.ExecutionTime.String(),
+		MemoryUsed:    fmt.Sprintf("%d KB", r.MemoryUsed),
+	}
 }

models/models.go

@@ -0,0 +1,23 @@
+package routes
+
+import (
+	"CodeSandboxAPI/dispatcher"
+	"CodeSandboxAPI/models"
+
+	"github.com/gin-gonic/gin"
+)
+
+func CallDispatcher(c *gin.Context) {
+	var req models.Request
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(400, gin.H{"error": "Invalid request format"})
+		return
+	}
+
+	resp, err := dispatcher.Dispatch(req)
+	if err != nil {
+		c.JSON(500, gin.H{"error": "Internal server error"})
+		return
+	}
+	c.JSON(200, resp)
+}

routes/execute.go

@@ -1,12 +1,11 @@
 package routes
 
 import (
-	"CodeSandboxAPI/dispatcher"
-
 	"github.com/gin-gonic/gin"
 )
 
 func Setup(router *gin.Engine) {
 	router.GET("/", root)
-	router.POST("/execute", dispatcher.CallDispatcher)
+	router.POST("/execute", CallDispatcher)
+	router.POST("/simple-execute", SimpleDispatcher)
 }

routes/main.go

@@ -0,0 +1,27 @@
+package routes
+
+import (
+	"CodeSandboxAPI/dispatcher"
+	"CodeSandboxAPI/models"
+	"fmt"
+
+	"github.com/gin-gonic/gin"
+)
+
+func SimpleDispatcher(c *gin.Context) {
+	var req models.SimpleRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(400, gin.H{"error": "Invalid request format"})
+		return
+	}
+
+	convertedReq := req.ToRequest()
+	resp, err := dispatcher.Dispatch(convertedReq)
+	convertedResp := resp.ToSimpleResponse()
+	if err != nil {
+		fmt.Printf("Error during dispatch: %v\n", err)
+		c.JSON(500, gin.H{"error": "Internal server error"})
+		return
+	}
+	c.JSON(200, convertedResp)
+}