Add nix runtime testing and pre-installing runtimes

api/default.nix

@@ -1,5 +1,5 @@
-{pkgs, ...}:
-with pkgs; {
+{pkgs, nosocket, ...}:
+with pkgs; rec {
   package = mkYarnPackage {
     name = "piston";
     src = ./.;
@@ -25,4 +25,47 @@ with pkgs; {
       };
     };
   };
+  container = pkgs.dockerTools.buildLayeredImageWithNixDb {
+    name = "piston";
+    tag = "base-latest";
+
+    contents = with pkgs; [
+      package
+      nosocket
+      bash
+      nixFlakes
+      coreutils-full
+      cacert.out
+      git
+      gnutar
+      gzip
+      gnugrep
+      util-linux
+    ];
+
+    extraCommands = ''
+      mkdir -p piston/{jobs,runtimes} etc/nix {,var/}tmp run/lock
+      echo -e "experimental-features = nix-command flakes" >> etc/nix/nix.conf
+      echo "nixbld:x:30000:nixbld1,nixbld10,nixbld11,nixbld12,nixbld13,nixbld14,nixbld15,nixbld16,nixbld17,nixbld18,nixbld19,nixbld2,nixbld20,nixbld21,nixbld22,nixbld23,nixbld24,nixbld25,nixbld26,nixbld27,nixbld28,nixbld29,nixbld3,nixbld30,nixbld31,nixbld32,nixbld4,nixbld5,nixbld6,nixbld7,nixbld8,nixbld9" >> etc/group
+      for i in $(seq 1 32)
+      do
+        echo "nixbld$i:x:$(( $i + 30000 )):30000:Nix build user $i:/var/empty:/run/current-system/sw/bin/nologin" >> etc/passwd
+      done
+    '';
+
+    config = {
+      Cmd = ["${package}/bin/pistond"];
+      Env = [
+        "NIX_PAGER=cat"
+        "USER=nobody"
+        "SSL_CERT_FILE=/etc/ssl/certs/ca-bundle.crt"
+        "GIT_SSL_CAINFO=/etc/ssl/certs/ca-bundle.crt"
+        "NIX_SSL_CERT_FILE=/etc/ssl/certs/ca-bundle.crt"
+      ];
+
+      ExposedPorts = {
+        "2000/tcp" = {};
+      };
+    };
+  };
 }

api/entrypoint.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-echo "Starting Piston API"
-
-echo "Checking presense of nix store"
-if [[ ! -f "/nix/piston_detected" ]]; then
-    echo "Nix Store is not loaded, assuming /nix has been mounted - copying contents"
-    cp -rp /var/nix/* /nix
-fi
-
-echo "Adding nix to env"
-. ~/.profile
-
-echo "Launching Piston API"
-node src

api/package.json

@@ -2,7 +2,7 @@
     "name": "piston-api",
     "version": "4.0.0",
     "description": "API for piston - a high performance code execution engine",
-    "main": "src/pistond.js",
+    "main": "src/bin/pistond.js",
     "dependencies": {
         "body-parser": "^1.19.0",
         "express": "^4.17.1",
@@ -23,6 +23,8 @@
         "prettier": "2.2.1"
     },
     "bin": {
-        "pistond": "./src/pistond.js"
+        "pistond": "./src/bin/pistond.js",
+        "piston-install": "./src/bin/install.js",
+        "piston-test": "./src/bin/test.js"
     }
 }

api/src/bin/install.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+// Downloads all packages specified into the nix store
+require('nocamel');
+const config = require('../config');
+const Logger = require('logplease');
+const logger = Logger.create('install');
+const cp = require('child_process');
+
+logger.info('Setting loglevel to', config.log_level);
+Logger.setLogLevel(config.log_level);
+
+const runtimes_path = `${config.flake_path}#pistonRuntimeSets.${config.runtime_set}`;
+logger.info(`Installing runtimes in ${runtimes_path}`);
+
+logger.debug("Getting package listing");
+const runtimes = JSON.parse(cp.execSync(`nix eval --json ${runtimes_path} --apply builtins.attrNames`));
+
+logger.info(`Got runtimes: ${runtimes}`);
+
+runtimes.forEach(runtime => {
+        logger.debug(`Loading metadata for ${runtime}`);
+        const runtime_metadata = JSON.parse(cp.execSync(`nix eval --json ${runtimes_path}.${runtime}.metadata`));
+        const namever = `${runtime}-${runtime_metadata.version}`;
+        logger.info(`Installing ${namever}`);
+        
+
+        function install(key){
+            logger.debug(`Installing ${namever}-${key}`);
+            const command = `nix build ${runtimes_path}.${runtime}.metadata.${key} -o /piston/runtimes/${namever}-${key}`;
+            cp.execSync(command);
+        }
+
+        install("run");
+        if(runtime_metadata.compile) install("compile");        
+
+        logger.info(`Installed ${namever}`);
+});
+
+logger.info("Done");

api/src/bin/pistond.js

@@ -3,16 +3,16 @@ require('nocamel');
 const Logger = require('logplease');
 const express = require('express');
 const expressWs = require('express-ws');
-const globals = require('./globals');
-const config = require('./config');
+const globals = require('../globals');
+const config = require('../config');
 const cp = require('child_process');
 const path = require('path');
 const fs = require('fs/promises');
 const fss = require('fs');
 const body_parser = require('body-parser');
-const runtime = require('./runtime');
+const runtime = require('../runtime');
 
-const logger = Logger.create('index');
+const logger = Logger.create('pistond');
 const app = express();
 expressWs(app);
 
@@ -41,7 +41,7 @@ expressWs(app);
 
     logger.info('Loading packages');
 
-    const runtimes_data = cp.execSync(`nix eval --json ${config.flake_path}#pistonRuntimes --apply builtins.attrNames`).toString();
+    const runtimes_data = cp.execSync(`nix eval --json ${config.flake_path}#pistonRuntimeSets.${config.runtime_set} --apply builtins.attrNames`).toString();
     const runtimes = JSON.parse(runtimes_data);
     
     runtimes.for_each(pkg => runtime.load_runtime(pkg));
@@ -61,8 +61,8 @@ expressWs(app);
 
     logger.debug('Registering Routes');
 
-    const api_v2 = require('./api/v2');
-    const api_v3 = require('./api/v3');
+    const api_v2 = require('../api/v2');
+    const api_v3 = require('../api/v3');
     app.use('/api/v2', api_v2);
     app.use('/api/v3', api_v3);
 

api/src/bin/test.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+// Test the specified package
+require('nocamel');
+const config = require('../config');
+const Logger = require('logplease');
+const logger = Logger.create('test');
+const cp = require('child_process');
+const runtime = require("../runtime");
+const { Job } = require('../job');
+
+(async function(){
+    logger.info('Setting loglevel to', config.log_level);
+    Logger.setLogLevel(config.log_level);
+
+    
+
+    let runtimes_to_test;
+    let failed = false;
+
+    if(process.argv[2] === "--all"){
+        // load all
+        runtimes_to_test = JSON.parse(
+            cp.execSync(`nix eval ${config.flake_path}#pistonRuntimes --json --apply builtins.attrNames`)
+        );
+    }else{
+        runtimes_to_test = [process.argv[2]];
+    }
+    
+
+
+    for (const runtime_name of runtimes_to_test) {
+        
+        
+        const runtime_path = `${config.flake_path}#pistonRuntimes.${runtime_name}`;
+        logger.info(`Testing runtime ${runtime_path}`);
+
+        logger.debug(`Loading runtime metadata`);
+        const metadata = JSON.parse(cp.execSync(`nix eval --json ${runtime_path}.metadata --json`));
+
+        logger.debug(`Loading runtime tests`);
+        const tests = JSON.parse(cp.execSync(`nix eval --json ${runtime_path}.tests --json`));
+
+        logger.debug(`Loading runtime`);
+
+        const testable_runtime = new runtime.Runtime({
+            ...metadata,
+            flake_path: runtime_path
+        });
+
+        testable_runtime.ensure_built();
+
+
+        logger.info(`Running tests`);
+
+        for (const test of tests) {
+
+            const files = [];
+
+            for (const file_name of Object.keys(test.files)) {
+                const file_content = test.files[file_name];
+                const this_file = {
+                    name: file_name,
+                    content: file_content
+                };
+
+                if(file_name == test.main)
+                    files.unshift(this_file);
+                else
+                    files.push(this_file);
+
+            }
+
+
+            const job = new Job({
+                runtime: testable_runtime,
+                args: test.args || [],
+                stdin: test.stdin || "",
+                files,
+                timeouts: {
+                    run: 3000,
+                    compile: 10000
+                },
+                memory_limits: {
+                    run: config.run_memory_limit,
+                    compile: config.compile_memory_limit
+                }
+            });
+
+            await job.prime()
+            const result = await job.execute()
+            await job.cleanup()
+            
+            if(result.run.stdout.trim() !== "OK"){
+                failed = true;
+
+                logger.error("Test Failed:")
+                console.log(job, result)
+            }else{
+                logger.info("Test Passed")
+            }
+        }
+    }
+
+    if(failed) {
+        logger.error("One or more tests failed")
+        process.exit(1);
+    }
+    else {
+        logger.info("All tests passed")
+        process.exit(0);
+    }
+})()

api/src/config.js

@@ -113,6 +113,12 @@ const options = [
         default: 'github:engineer-man/piston?directory=packages',
         validators: [],
     },
+    {
+        key: 'runtime_set',
+        desc: 'Key on the flake specified by flake_path to access runtimes from',
+        default: 'all',
+        validators: []
+    },
     {
         key: 'max_concurrent_jobs',
         desc: 'Maximum number of concurrent jobs to run at one time',

api/src/runtime.js

@@ -9,7 +9,7 @@ const runtimes = [];
 
 
 class Runtime {
-    constructor({ language, version, aliases, runtime, run, compile, packageSupport, flake_key }) {
+    constructor({ language, version, aliases, runtime, run, compile, packageSupport, flake_path }) {
         this.language = language;
         this.runtime = runtime;
         this.aliases = aliases;
@@ -18,17 +18,17 @@ class Runtime {
         this.run = run;
         this.compile = compile;
 
-        this.flake_key = flake_key;
+        this.flake_path = flake_path;
         this.package_support = packageSupport;
     }
 
     ensure_built(){
         logger.info(`Ensuring ${this} is built`);
 
-        const flake_key = this.flake_key;
+        const flake_path = this.flake_path;
 
         function _ensure_built(key){
-            const command = `nix build ${config.flake_path}#pistonRuntimes.${flake_key}.metadata.${key} --no-link`;
+            const command = `nix build ${flake_path}.metadata.${key} --no-link`;
             cp.execSync(command, {stdio: "pipe"})
         }
 
@@ -41,12 +41,13 @@ class Runtime {
 
     static load_runtime(flake_key){
         logger.info(`Loading ${flake_key}`)
-        const metadata_command = `nix eval --json ${config.flake_path}#pistonRuntimes.${flake_key}.metadata`;
+        const flake_path = `${config.flake_path}#pistonRuntimeSets.${config.runtime_set}.${flake_key}`;
+        const metadata_command = `nix eval --json ${flake_path}.metadata`;
         const metadata = JSON.parse(cp.execSync(metadata_command));
         
         const this_runtime = new Runtime({
             ...metadata,
-            flake_key
+            flake_path
         });
 
         this_runtime.ensure_built();