Add nix runtime testing and pre-installing runtimes

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);
 
@@ -39,7 +39,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));
@@ -59,8 +59,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

@@ -176,6 +176,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

@@ -17,7 +17,7 @@ class Runtime {
         run,
         compile,
         packageSupport,
-        flake_key,
+        flake_path,
         timeouts,
         memory_limits,
         max_process_count,
@@ -41,7 +41,7 @@ class Runtime {
         this.run = run;
         this.compile = compile;
 
-        this.flake_key = flake_key;
+        this.flake_path = flake_path;
         this.package_support = packageSupport;
     }
     
@@ -112,10 +112,10 @@ class Runtime {
     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"})
         }
 
@@ -128,7 +128,8 @@ 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({
@@ -137,7 +138,7 @@ class Runtime {
                 metadata.language,
                 metadata.limit_overrides
             ),
-            flake_key
+            flake_path
         });
 
         this_runtime.ensure_built();