prettify code, fix bugs, make it isolated compile with gcc

runner/runner.go

@@ -14,22 +14,57 @@ import (
 )
 
 const runIdLength = 20
-var coresIsolated []int
 
 type Limits struct {
-    Core    int
-    Memory  int
-    Time    int
+    Processes int32
+    Core      int32
+    Memory    int32
+    Time      int32
 }
 
-func extractNumbers(s string) (result []int) {
+const Mib = 1024*1024;
+const BuildMemory = 1024*Mib;
+const BuildTime = 5000;
+
+type RunnerService struct {
+    CoresIsolated []int32
+    CoreFreed chan int32
+}
+
+func genRunId() (runId string) {
+    for i := 0; i < runIdLength; i++ {
+        runId += string('a' + byte(rand.Int31n(26)))
+    }
+    return
+}
+
+func int32ToString(n int32) string {
+    return fmt.Sprintf("%d", n)
+}
+
+func copyFile(src string,dst string) error {
+    log.Println(src,dst)
+    srcFile,err := os.Open(src)
+    if(err!=nil) {return err}
+    defer srcFile.Close()
+    dstFile,err := os.Create(dst)
+    if(err!=nil) {return err}
+    defer dstFile.Close()
+    _,err = io.Copy(dstFile,srcFile)
+    if(err!=nil) {return err}
+    err = dstFile.Sync()
+    if(err!=nil) {return err}
+    return nil
+}
+
+func extractNumbers(s string) (result []int32) {
     lastNumber, isNumber := false,false
-    var curNumber = 0
+    var curNumber int32 = 0
     for _, char := range s {
         isNumber = (char >= '0' && char <= '9')
         if(isNumber) {
             curNumber *= 10
-            curNumber += int(char - '0')
+            curNumber += int32(char - '0')
         }
         if(!isNumber && lastNumber) {
             result = append(result, curNumber)
@@ -43,13 +78,14 @@ func extractNumbers(s string) (result []int) {
     return
 }
 
-func Init() error {
+func NewRunnerService() (*RunnerService, error) {
+    runnerService := RunnerService{make([]int32,0),make(chan int32)} 
     rand.Seed(time.Now().UnixNano())
     //croup initialisation:
     if cgroups.Mode() == cgroups.Unified {
         log.Println("cgroups v2 usage approved")
     } else {
-        return fmt.Errorf("cgroups v2 are not enabled")//TODO: trouble description
+        return nil,fmt.Errorf("cgroups v2 are not enabled")//TODO: trouble description
     }
     //isolated cores initialisation:
     cmdlineBytes := make([]byte, 400)
@@ -59,29 +95,55 @@ func Init() error {
     kernelParams := strings.Split(cmdline," ")
     for _, param := range kernelParams{
         if(len(param) >= 9 && param[:9] == "isolcpus=") {
-            coresIsolated = append(coresIsolated, extractNumbers(param[9:])...)
+            runnerService.CoresIsolated = append(runnerService.CoresIsolated, extractNumbers(param[9:])...)
         }
     }
-    if(len(coresIsolated) == 0) {
-        return fmt.Errorf("no free cores available")//TODO: trouble description
+    if(len(runnerService.CoresIsolated) == 0) {
+        return nil,fmt.Errorf("no free cores available")//TODO: trouble description
     }
-    log.Println("running on cores:", coresIsolated)
+    go func() {
+        for _,core := range runnerService.CoresIsolated {
+            runnerService.CoreFreed <- core
+        }
+    }()
+    log.Println("running on cores:", runnerService.CoresIsolated)
+    //runs directory
+    os.Mkdir("runs",0777)
+    os.Chmod("runs",0777)
+    //complete
     log.Println("Runner initialisation successful!")
-    return nil
+    return &runnerService,nil
 }
 
-func IsolatedRun(command []string, limits Limits) {
-    var runId string
-    for i := 0; i < runIdLength; i++ {runId += string('a' + byte(rand.Int31n(26)))}
-    os.Mkdir("starter/" + runId, 0777)
-    args := []string{string(limits.Core), string(limits.Memory), string(limits.Time), runId}
+func (runnerService RunnerService) Build(buildCmd []string, filename string) {
+    core := <-runnerService.CoreFreed
+    runId := genRunId()
+    err := os.Mkdir("runs/" + runId, 0777)
+    if(err!=nil) { log.Fatal(err) }
+    os.Chmod("runs/" + runId, 0777)
+    copyFile("starter/shared/main.c","runs/"+runId+"/main.c")//FIXME add source and file extension
+    runnerService.IsolatedRun([]string{"/usr/bin/gcc","/shared/main.c","-o","/shared/executable","-save-temps=obj"},"../runs/"+runId,Limits{Processes: 10,Core:core,Memory:BuildMemory,Time:BuildTime});
+    copyFile("runs/"+runId+"/executable","destination")//FIXME add destination
+    os.RemoveAll("runs/" + runId)
+    go func() {
+        runnerService.CoreFreed <- core
+    }()
+}
+
+func (runnerService RunnerService) IsolatedRun(command []string, sharedFolder string, limits Limits) {
+    args := []string{int32ToString(limits.Processes),int32ToString(limits.Core), int32ToString(limits.Memory), int32ToString(limits.Time), sharedFolder}
     args = append(args, command...)
+    log.Println(limits.Processes)
+    log.Println(string(limits.Processes))
+    log.Println(args)
     cmd := exec.Command("starter/starter", args...)
     var stdBuffer bytes.Buffer
     mw := io.MultiWriter(os.Stdout, &stdBuffer)
     cmd.Stdout = mw
     err := cmd.Run();
-    if err != nil { log.Fatal(err) }
-    os.RemoveAll("starter/" + runId)
-    cmd.Wait()
+    if err != nil {
+        log.Println(123)
+        log.Println(err)
+    }
+    //cmd.Wait()
 }