api/src/config.js

@@ -2,119 +2,139 @@ const fss = require('fs');
 const Logger = require('logplease');
 const logger = Logger.create('config');
 
-const options = {
+const options = [
-    log_level: {
+    {
+        key: 'log_level',
         desc: 'Level of data to log',
         default: 'INFO',
+        options: Object.values(Logger.LogLevels),
         validators: [
             x =>
                 Object.values(Logger.LogLevels).includes(x) ||
                 `Log level ${x} does not exist`,
         ],
     },
-    bind_address: {
+    {
+        key: 'bind_address',
         desc: 'Address to bind REST API on',
         default: `0.0.0.0:${process.env['PORT'] || 2000}`,
         validators: [],
     },
-    data_directory: {
+    {
+        key: 'data_directory',
         desc: 'Absolute path to store all piston related data at',
         default: '/piston',
         validators: [
             x => fss.exists_sync(x) || `Directory ${x} does not exist`,
         ],
     },
-    runner_uid_min: {
+    {
+        key: 'runner_uid_min',
         desc: 'Minimum uid to use for runner',
         default: 1001,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    runner_uid_max: {
+    {
+        key: 'runner_uid_max',
         desc: 'Maximum uid to use for runner',
         default: 1500,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    runner_gid_min: {
+    {
+        key: 'runner_gid_min',
         desc: 'Minimum gid to use for runner',
         default: 1001,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    runner_gid_max: {
+    {
+        key: 'runner_gid_max',
         desc: 'Maximum gid to use for runner',
         default: 1500,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    disable_networking: {
+    {
+        key: 'disable_networking',
         desc: 'Set to true to disable networking',
         default: true,
         parser: x => x === 'true',
         validators: [x => typeof x === 'boolean' || `${x} is not a boolean`],
     },
-    output_max_size: {
+    {
+        key: 'output_max_size',
         desc: 'Max size of each stdio buffer',
         default: 1024,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    max_process_count: {
+    {
+        key: 'max_process_count',
         desc: 'Max number of processes per job',
         default: 64,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    max_open_files: {
+    {
+        key: 'max_open_files',
         desc: 'Max number of open files per job',
         default: 2048,
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    max_file_size: {
+    {
+        key: 'max_file_size',
         desc: 'Max file size in bytes for a file',
         default: 10000000, //10MB
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    compile_timeout: {
+    {
+        key: 'compile_timeout',
         desc: 'Max time allowed for compile stage in milliseconds',
         default: 10000, // 10 seconds
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    run_timeout: {
+    {
+        key: 'run_timeout',
         desc: 'Max time allowed for run stage in milliseconds',
         default: 3000, // 3 seconds
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    compile_memory_limit: {
+    {
+        key: 'compile_memory_limit',
         desc: 'Max memory usage for compile stage in bytes (set to -1 for no limit)',
         default: -1, // no limit
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    run_memory_limit: {
+    {
+        key: 'run_memory_limit',
         desc: 'Max memory usage for run stage in bytes (set to -1 for no limit)',
         default: -1, // no limit
         parser: parse_int,
         validators: [(x, raw) => !is_nan(x) || `${raw} is not a number`],
     },
-    repo_url: {
+    {
+        key: 'repo_url',
         desc: 'URL of repo index',
         default:
             'https://github.com/engineer-man/piston/releases/download/pkgs/index',
         validators: [],
     },
-    max_concurrent_jobs: {
+    {
+        key: 'max_concurrent_jobs',
         desc: 'Maximum number of concurrent jobs to run at one time',
         default: 64,
         parser: parse_int,
         validators: [x => x > 0 || `${x} cannot be negative`],
     },
-    limit_overrides: {
+    {
+        key: 'limit_overrides',
         desc: 'Per-language exceptions in JSON format for each of:\
         max_process_count, max_open_files, max_file_size, compile_memory_limit,\
         run_memory_limit, compile_timeout, run_timeout, output_max_size',
@@ -125,7 +145,7 @@ const options = {
             validate_overrides,
         ],
     },
-};
+];
 
 Object.freeze(options);
 
@@ -149,7 +169,7 @@ function parse_overrides(overrides_string) {
     }
 
     const overrides = get_parsed_json_or_null(overrides_string);
-    if (overrides === null) {
+    if (typeof overrides === null) {
         return null;
     }
     const parsed_overrides = {};
@@ -171,11 +191,11 @@ function parse_overrides(overrides_string) {
                 return null;
             }
             // Find the option for the override
-            const option = options[key];
+            const option = options.find(o => o.key === key);
             const parser = option.parser;
-            const raw_value = overrides[language][key];
+            const raw = overrides[language][key];
-            const parsed_value = parser(raw_value);
+            const value = parser(raw);
-            parsed_overrides[language][key] = parsed_value;
+            parsed_overrides[language][key] = value;
         }
     }
     return parsed_overrides;
@@ -185,7 +205,7 @@ function validate_overrides(overrides) {
     for (const language in overrides) {
         for (const key in overrides[language]) {
             const value = overrides[language][key];
-            const option = options[key];
+            const option = options.find(o => o.key === key);
             const validators = option.validators;
             const validation_response = apply_validators(validators, [
                 value,
@@ -203,9 +223,8 @@ logger.info(`Loading Configuration from environment`);
 
 let config = {};
 
-for (const option_name in options) {
+options.forEach(option => {
-    const env_key = 'PISTON_' + option_name.to_upper_case();
+    const env_key = 'PISTON_' + option.key.to_upper_case();
-    const option = options[option_name];
     const parser = option.parser || (x => x);
     const env_val = process.env[env_key];
     const parsed_val = parser(env_val);
@@ -218,13 +237,13 @@ for (const option_name in options) {
     );
     if (validation_response !== true) {
         logger.error(
-            `Config option ${option_name} failed validation:`,
+            `Config option ${option.key} failed validation:`,
             validation_response
         );
         process.exit(1);
     }
-    config[option_name] = value;
+    config[option.key] = value;
-}
+});
 
 logger.info('Configuration successfully loaded');