@miso.ai/server-jobs 0.6.5-beta.10

package/cli/config.js

@@ -0,0 +1,7 @@
+import { loadConfig as _loadConfig } from '@miso.ai/server-commons';
+
+const DEFAULT_CONFIG_FILE = 'jobs.yml';
+
+export async function loadConfig(file = DEFAULT_CONFIG_FILE) {
+  return _loadConfig(file);
+}

package/cli/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { yargs } from '@miso.ai/server-commons';
+import version from '../src/version.js';
+import run from './run.js';
+
+yargs.build(yargs => {
+  yargs
+    .command(run)
+    .version(version);
+});

package/cli/run.js

@@ -0,0 +1,33 @@
+import { loadConfig } from './config.js';
+import { runJob } from '../src/index.js';
+
+function build(yargs) {
+  return yargs
+    .positional('name', {
+      describe: 'Job name',
+    })
+    .option('config', {
+      alias: ['c'],
+      describe: 'Config file',
+    });
+}
+
+async function run({ name, config: configFile, ...options } = {}) {
+  const config = await loadConfig(configFile);
+  const job = findJob(config, name);
+  if (!job) {
+    throw new Error(`Job not found: ${name}`);
+  }
+  await runJob(job, options);
+}
+
+function findJob(config, name) {
+  return config.jobs.find(job => job.name === name);
+}
+
+export default {
+  command: 'run [name]',
+  desc: 'Run a job',
+  builder: build,
+  handler: run,
+};

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@miso.ai/server-jobs",
+  "description": "Miso job tools",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "miso-jobs": "cli/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {},
+  "repository": "MisoAI/miso-server-js-sdk",
+  "license": "MIT",
+  "contributors": [
+    "simonpai <simon.pai@askmiso.com>"
+  ],
+  "dependencies": {
+    "@miso.ai/server-commons": "0.6.5-beta.10"
+  },
+  "version": "0.6.5-beta.10"
+}

package/src/constants.js

@@ -0,0 +1,21 @@
+function logLevel(NAME, VALUE) {
+  return Object.freeze({ NAME, VALUE });
+}
+
+const LOG_LEVELS = [
+  logLevel('fatal', 0),
+  logLevel('error', 5),
+  logLevel('warn', 10),
+  logLevel('report', 10),
+  logLevel('info', 15),
+  logLevel('debug', 20),
+];
+
+export const LOG_LEVEL = Object.freeze(LOG_LEVELS.reduce((acc, level) => {
+  acc[level.NAME.toUpperCase()] = level;
+  return acc;
+}, {}));
+
+export function getLogLevelValue(name) {
+  return (LOG_LEVEL[name.toUpperCase()] || LOG_LEVEL.INFO).VALUE;
+}

package/src/index.js

@@ -0,0 +1 @@
+export * from './tasks.js';

package/src/logs.js

@@ -0,0 +1,95 @@
+import { LOG_LEVEL, getLogLevelValue } from './constants.js';
+
+export function generateJobId() {
+  // 4-char random string
+  return Math.random().toString(36).slice(2, 6).toLowerCase();
+}
+
+export function createLogFunction(context = {}, {
+  logOutput = defaultLogOutput,
+  logFilter = () => true,
+  logLevel = LOG_LEVEL.INFO.NAME,
+} = {}) {
+  if (typeof logOutput !== 'function') {
+    throw new Error('output must be a function');
+  }
+  const logLevelThreshold = getLogLevelValue(logLevel);
+  return (...args) => {
+    const event = normalizeEvent(context, args);
+    const { level = LOG_LEVEL.INFO.NAME } = event;
+    const logLevelValue = getLogLevelValue(level);
+    if (logLevelValue > logLevelThreshold) {
+      return;
+    }
+    if (!logFilter(event)) {
+      return;
+    }
+    const message = formatEvent(event);
+    logOutput(level, message);
+  };
+}
+
+function normalizeEvent(context, args) {
+  let event, level = LOG_LEVEL.INFO.NAME;
+  if (args.length > 1) {
+    level = args[0];
+    event = args[1];
+  } else {
+    event = args[0];
+  }
+  if (typeof event === 'string') {
+    event = { message: event };
+  }
+  event = { ...context, level, ...event };
+  return event;
+}
+
+function formatEvent({ job, task, type, level, message = '', ...event } = {}) {
+  let tags = '';
+  if (job) {
+    tags += formatJobTag(job);
+  }
+  if (task) {
+    tags += formatTaskTag(task);
+  }
+  if (level) {
+    tags += `[${level}]`;
+  }
+  if (type) {
+    tags += `[${type}]`;
+  }
+  message = message || JSON.stringify(event);
+  return `${tags} ${message}`;
+}
+
+function formatJobTag(job) {
+  if (typeof job === 'string') {
+    return `[${job}]`;
+  }
+  let tags = '';
+  if (job.id) {
+    tags += `[${job.id}]`;
+  }
+  if (job.name) {
+    tags += `[${job.name}]`;
+  }
+  return tags;
+}
+
+function formatTaskTag(task) {
+  if (typeof task === 'string') {
+    return `[${task}]`;
+  }
+  return `[${task.name || task.id}]`;
+}
+
+function defaultLogOutput(level, message) {
+  switch (level) {
+    case LOG_LEVEL.FATAL.NAME:
+    case LOG_LEVEL.ERROR.NAME:
+      console.error(message);
+      break;
+    default:
+      console.log(message);
+  }
+}

package/src/process.js

@@ -0,0 +1,25 @@
+import { spawn as _spawn } from 'child_process';
+
+export async function spawn(command, args, { onStdout, onStderr, ...options } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = _spawn(command, args, options);
+
+    if (typeof onStdout === 'function') {
+      child.stdout.on('data', data => onStdout(data.toString()));
+    }
+    if (typeof onStderr === 'function') {
+      child.stderr.on('data', data => onStderr(data.toString()));
+    }
+
+    // fatal errors, like ENOENT, EACCES
+    child.on('error', reject);
+
+    child.on('close', (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command ${command} failed with code ${code} and signal ${signal}`));
+      }
+    });
+  });
+}

package/src/tasks.js

@@ -0,0 +1,75 @@
+import { LOG_LEVEL } from './constants.js';
+import { spawn } from './process.js';
+import { createLogFunction, generateJobId } from './logs.js';
+import { formatDuration } from './utils.js';
+
+export async function runJob(job, options = {}) {
+  job = normalizeJob(job);
+  const log = createLogFunction({ job }, options);
+  const { tasks = [] } = job;
+
+  log(`Starting job with ${tasks.length} tasks`);
+
+  let index = 0;
+  for (let task of tasks) {
+    task = normalizeTask(task, index);
+    await runTask(job, task, options);
+    index++;
+  }
+
+  const endTime = Date.now();
+  const elapsed = endTime - job.timestamp;
+  log(`Job done in ${formatDuration(elapsed)}`);
+}
+
+async function runTask(job, task, options = {}) {
+  const log = createLogFunction({ job, task }, options);
+  const { command, args, shell } = task;
+  log(`Starting task: ${formatTaskCommand(task)}`);
+
+  await spawn(command, args || [], {
+    shell,
+    onStdout: data => log(parseJsonIfNecessary(data)),
+    onStderr: data => log(LOG_LEVEL.ERROR.NAME, parseJsonIfNecessary(data)),
+    ...options,
+  });
+
+  const endTime = Date.now();
+  const elapsed = endTime - task.timestamp;
+  log(`Task done in ${formatDuration(elapsed)}`);
+}
+
+function normalizeJob(job) {
+  job = { ...job, timestamp: Date.now() };
+  if (!job.id) {
+    job.id = generateJobId();
+  }
+  return job;
+}
+
+function normalizeTask(task, index) {
+  task = { ...task, index, timestamp: Date.now() };
+  if (!task.id) {
+    task.id = generateJobId();
+  }
+  return task;
+}
+
+function formatTaskCommand({ command, args = [] }) {
+  return [command, ...args].join(' ');
+}
+
+function parseJsonIfNecessary(data) {
+  if (typeof data !== 'string') {
+    return data;
+  }
+  data = data.trim();
+  if (!data.startsWith('{') || !data.endsWith('}')) {
+    return data;
+  }
+  try {
+    return JSON.parse(data);
+  } catch (_) {
+    return data;
+  }
+}

package/src/utils.js

@@ -0,0 +1,25 @@
+export function formatDuration(value) {
+  if (isNaN(value)) {
+    throw new Error(`Value must be a number: ${value}`);
+  }
+  value = Math.floor(value);
+  const ms = value % 1000;
+  value = Math.floor(value / 1000);
+  const sec = value % 60;
+  value = Math.floor(value / 60);
+  const min = value % 60;
+  value = Math.floor(value / 60);
+  const hour = value;
+  const lessThanOneMinute = hour === 0 && min === 0;
+  let str = '';
+  if (hour > 0) {
+    str += `${hour}h`;
+  }
+  if (min > 0) {
+    str += `${min}m`;
+  }
+  if (lessThanOneMinute || sec > 0 || ms > 0) {
+    str += lessThanOneMinute ? `${sec}.${ms}s` : `${sec}s`;
+  }
+  return str;
+}

package/src/version.js

@@ -0,0 +1 @@
+export default '0.6.5-beta.10';