qdone 1.7.0 → 2.0.0-alpha

package/src/worker.js

@@ -1,68 +1,86 @@
+/**
+ * Implementation for the worker that pulls jobs from queue and executes them.
+ */
 
-const Q = require('q')
-const childProcess = require('child_process')
-const debug = require('debug')('qdone:worker')
-const chalk = require('chalk')
-const treeKill = require('tree-kill')
-const qrlCache = require('./qrlCache')
-const cheapIdleCheck = require('./idleQueues').cheapIdleCheck
-const AWS = require('aws-sdk')
-var shutdownRequested = false
+import {
+  ChangeMessageVisibilityCommand,
+  ReceiveMessageCommand,
+  DeleteMessageCommand
+} from '@aws-sdk/client-sqs'
+import { exec } from 'child_process' // node:child_process
+import treeKill from 'tree-kill'
+import chalk from 'chalk'
+import Debug from 'debug'
 
-exports.requestShutdown = function requestShutdown () {
+import { normalizeQueueName, getQnameUrlPairs } from './qrlCache.js'
+import { getOptionsWithDefaults } from './defaults.js'
+import { cheapIdleCheck } from './idleQueues.js'
+import { getSQSClient } from './sqs.js'
+
+const debug = Debug('qdone:worker')
+
+// Global flag for shutdown request
+let shutdownRequested = false
+
+export function requestShutdown () {
   shutdownRequested = true
 }
 
 //
 // Actually run the subprocess job
 //
-function executeJob (job, qname, qrl, options) {
+export async function executeJob (job, qname, qrl, opt) {
   debug('executeJob', job)
   const cmd = 'nice ' + job.Body
-  if (options.verbose) console.error(chalk.blue('  Executing job command:'), cmd)
+  if (opt.archive) {
+    await getSQSClient().send(new DeleteMessageCommand({
+      QueueUrl: qrl,
+      ReceiptHandle: job.ReceiptHandle
+    }))
+    console.log(cmd)
+    return { noJobs: 0, jobsSucceeded: 1, jobsFailed: 0 }
+  }
+  if (opt.verbose) console.error(chalk.blue('  Executing job command:'), cmd)
 
-  var jobStart = new Date()
-  var visibilityTimeout = 30 // this should be the queue timeout
-  var timeoutExtender
+  const jobStart = new Date()
+  let visibilityTimeout = 30 // this should be the queue timeout
+  let timeoutExtender
 
-  function extendTimeout () {
+  async function extendTimeout () {
     debug('extendTimeout')
     const maxJobRun = 12 * 60 * 60
     const jobRunTime = ((new Date()) - jobStart) / 1000
     // Double every time, up to max
-    visibilityTimeout = Math.min(visibilityTimeout * 2, maxJobRun - jobRunTime, options['kill-after'] - jobRunTime)
-    if (options.verbose) {
+    visibilityTimeout = Math.min(visibilityTimeout * 2, maxJobRun - jobRunTime, opt.killAfter - jobRunTime)
+    if (opt.verbose) {
       console.error(
         chalk.blue('  Ran for ') + jobRunTime +
         chalk.blue(' seconds, requesting another ') + visibilityTimeout +
         chalk.blue(' seconds')
       )
     }
-    const sqs = new AWS.SQS()
-    sqs
-      .changeMessageVisibility({
+
+    try {
+      const result = await getSQSClient().send(new ChangeMessageVisibilityCommand({
         QueueUrl: qrl,
         ReceiptHandle: job.ReceiptHandle,
         VisibilityTimeout: visibilityTimeout
-      })
-      .promise()
-      .then(function (result) {
-        debug('changeMessageVisibility.then returned', result)
-        if (
-          jobRunTime + visibilityTimeout >= maxJobRun ||
-          jobRunTime + visibilityTimeout >= options['kill-after']
-        ) {
-          if (options.verbose) console.error(chalk.yellow('  warning: this is our last time extension'))
-        } else {
-          // Extend when we get 50% of the way to timeout
-          timeoutExtender = setTimeout(extendTimeout, visibilityTimeout * 1000 * 0.5)
-        }
-      })
-      .catch(function (err) {
-        debug('changeMessageVisibility.catch returned', err)
-        // Rejection means we're ouuta time, whatever, let the job die
-        if (options.verbose) console.error(chalk.red('  failed to extend job: ') + err)
-      })
+      }))
+      debug('ChangeMessageVisibility.then returned', result)
+      if (
+        jobRunTime + visibilityTimeout >= maxJobRun ||
+        jobRunTime + visibilityTimeout >= opt.killAfter
+      ) {
+        if (opt.verbose) console.error(chalk.yellow('  warning: this is our last time extension'))
+      } else {
+        // Extend when we get 50% of the way to timeout
+        timeoutExtender = setTimeout(extendTimeout, visibilityTimeout * 1000 * 0.5)
+      }
+    } catch (err) {
+      debug('changeMessageVisibility.catch returned', err)
+      // Rejection means we're ouuta time, whatever, let the job die
+      if (opt.verbose) console.error(chalk.red('  failed to extend job: ') + err)
+    }
   }
 
   // Extend when we get 50% of the way to timeout
@@ -73,84 +91,84 @@ function executeJob (job, qname, qrl, options) {
   // it does not seem to work for child processes of the shell, so we'll create our
   // own timeout and use tree-kill to catch all of the child processes.
 
-  let child
+  let child, sigKillTimeout
   function killTree () {
     debug('killTree', child.pid)
     treeKill(child.pid, 'SIGTERM')
     setTimeout(function () {
-      treeKill(child.pid, 'SIGKILL')
+      sigKillTimeout = treeKill(child.pid, 'SIGKILL')
     }, 1000)
   }
-  const treeKiller = setTimeout(killTree, options['kill-after'] * 1000)
-  debug({ treeKiller: options['kill-after'] * 1000, date: Date.now() })
+  const treeKiller = setTimeout(killTree, opt.killAfter * 1000)
+  debug({ treeKiller: opt.killAfter * 1000, date: Date.now() })
 
-  const promise = new Promise(function (resolve, reject) {
-    child = childProcess.exec(cmd, function (err, stdout, stderr) {
-      if (err) reject(err, stdout, stderr)
-      else resolve(stdout, stderr)
+  try {
+    // Success path for job execution
+    const { stdout, stderr } = await new Promise(function (resolve, reject) {
+      child = exec(cmd, function (err, stdout, stderr) {
+        if (err) {
+          err.stdout = stdout
+          err.stderr = stderr
+          reject(err)
+        } else resolve({ stdout, stderr })
+      })
     })
-  })
 
-  return promise
-    // Q.nfcall(childProcess.exec, cmd, {timeout: options['kill-after'] * 1000})
-    .then(function (stdout, stderr) {
-      debug('childProcess.exec.then', Date.now())
-      clearTimeout(timeoutExtender)
-      clearTimeout(treeKiller)
-      if (options.verbose) {
-        console.error(chalk.green('  SUCCESS'))
-        if (stdout) console.error(chalk.blue('  stdout: ') + stdout)
-        if (stderr) console.error(chalk.blue('  stderr: ') + stderr)
-        console.error(chalk.blue('  cleaning up (removing job) ...'))
-      }
-      const sqs = new AWS.SQS()
-      return sqs
-        .deleteMessage({
-          QueueUrl: qrl,
-          ReceiptHandle: job.ReceiptHandle
-        })
-        .promise()
-        .then(function () {
-          if (options.verbose) {
-            console.error(chalk.blue('  done'))
-            console.error()
-          }
-          return Promise.resolve({ noJobs: 0, jobsSucceeded: 1, jobsFailed: 0 })
-        })
-    })
-    .catch((err, stdout, stderr) => {
-      debug('childProcess.exec.catch')
-      clearTimeout(timeoutExtender)
-      clearTimeout(treeKiller)
-      if (options.verbose) {
-        console.error(chalk.red('  FAILED'))
-        if (err.code) console.error(chalk.blue('  code  : ') + err.code)
-        if (err.signal) console.error(chalk.blue('  signal: ') + err.signal)
-        if (stdout) console.error(chalk.blue('  stdout: ') + stdout)
-        if (stderr) console.error(chalk.blue('  stderr: ') + stderr)
-        console.error(chalk.blue('  error : ') + err)
-      } else {
-        // Production error logging
-        console.log(JSON.stringify({
-          event: 'JOB_FAILED',
-          timestamp: new Date(),
-          job: job.MessageId,
-          command: job.Body,
-          exitCode: err.code || undefined,
-          killSignal: err.signal || undefined,
-          stderr,
-          stdout,
-          errorMessage: err.toString().split('\n').slice(1).join('\n').trim() || undefined
-        }))
-      }
-      return Promise.resolve({ noJobs: 0, jobsSucceeded: 0, jobsFailed: 1 })
-    })
+    debug('exec.then', Date.now())
+    clearTimeout(timeoutExtender)
+    clearTimeout(treeKiller)
+    clearTimeout(sigKillTimeout)
+    if (opt.verbose) {
+      console.error(chalk.green('  SUCCESS'))
+      if (stdout) console.error(chalk.blue('  stdout: ') + stdout)
+      if (stderr) console.error(chalk.blue('  stderr: ') + stderr)
+      console.error(chalk.blue('  cleaning up (removing job) ...'))
+    }
+    await getSQSClient().send(new DeleteMessageCommand({
+      QueueUrl: qrl,
+      ReceiptHandle: job.ReceiptHandle
+    }))
+    if (opt.verbose) {
+      console.error(chalk.blue('  done'))
+      console.error()
+    }
+    return { noJobs: 0, jobsSucceeded: 1, jobsFailed: 0 }
+  } catch (err) {
+    // Fail path for job execution
+    debug('exec.catch')
+    clearTimeout(timeoutExtender)
+    clearTimeout(treeKiller)
+    clearTimeout(sigKillTimeout)
+    if (opt.verbose) {
+      const { code, signal, stdout, stderr } = err
+      console.error(chalk.red('  FAILED'))
+      if (code) console.error(chalk.blue('  code  : ') + code)
+      if (signal) console.error(chalk.blue('  signal: ') + signal)
+      if (stdout) console.error(chalk.blue('  stdout: ') + stdout)
+      if (stderr) console.error(chalk.blue('  stderr: ') + stderr)
+      console.error(chalk.blue('  error : ') + err)
+    } else {
+      // Production error logging
+      console.log(JSON.stringify({
+        event: 'JOB_FAILED',
+        timestamp: new Date(),
+        job: job.MessageId,
+        command: job.Body,
+        exitCode: err.code || err.code || undefined,
+        killSignal: err.signal || undefined,
+        stderr: err.stderr,
+        stdout: err.stdout,
+        errorMessage: err.toString().split('\n').slice(1).join('\n').trim() || undefined
+      }))
+    }
+    return { noJobs: 0, jobsSucceeded: 0, jobsFailed: 1 }
+  }
 }
 
 //
 // Pull work off of a single queue
 //
-function pollForJobs (qname, qrl, options) {
+export async function pollForJobs (qname, qrl, opt) {
   debug('pollForJobs')
   const params = {
     AttributeNames: ['All'],
@@ -158,116 +176,93 @@ function pollForJobs (qname, qrl, options) {
     MessageAttributeNames: ['All'],
     QueueUrl: qrl,
     VisibilityTimeout: 30,
-    WaitTimeSeconds: options['wait-time']
+    WaitTimeSeconds: opt.waitTime
+  }
+  const response = await getSQSClient().send(new ReceiveMessageCommand(params))
+  debug('sqs.receiveMessage.then', response)
+  if (shutdownRequested) return { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 }
+  if (response.Messages) {
+    const job = response.Messages[0]
+    if (opt.verbose) console.error(chalk.blue('  Found job ' + job.MessageId))
+    return executeJob(job, qname, qrl, opt)
+  } else {
+    return { noJobs: 1, jobsSucceeded: 0, jobsFailed: 0 }
   }
-  const sqs = new AWS.SQS()
-  return sqs
-    // .receiveMessage(params, function (err, response) { if (err) throw err })
-    .receiveMessage(params)
-    .promise()
-    .then(function (response) {
-      debug('sqs.receiveMessage.then', response)
-      if (shutdownRequested) return Promise.resolve({ noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 })
-      if (response.Messages) {
-        const job = response.Messages[0]
-        if (options.verbose) console.error(chalk.blue('  Found job ' + job.MessageId))
-        return executeJob(job, qname, qrl, options)
-      } else {
-        return Promise.resolve({ noJobs: 1, jobsSucceeded: 0, jobsFailed: 0 })
-      }
-    })
 }
 
 //
 // Resolve queues for listening loop listen
 //
-exports.listen = function listen (queues, options) {
-  if (options.verbose) console.error(chalk.blue('Resolving queues: ') + queues.join(' '))
-  const qnames = queues.map(function (queue) { return options.prefix + qrlCache.normalizeQueueName(queue, options) })
-  debug({ hello: '?' })
-  return qrlCache
-    .getQnameUrlPairs(qnames, options)
-    .then(function (entries) {
-      // If user only wants active queues, run a cheap idle check
-      if (options['active-only']) {
-        debug({ entiresBeforeCheck: entries })
-        return Promise.all(entries.map(entry =>
-          cheapIdleCheck(entry.qname, entry.qrl, options)
-            .then(({ result }) =>
-              Promise.resolve(
-                Object.assign(entry, { idle: result.idle })
-              )
-            )
-        ))
-      } else {
-        return entries
-      }
-    })
-    .then(function (entries) {
-      if (options['active-only']) {
-        // Filter out idle queues
-        return entries.filter(entry => entry && entry.idle !== true)
-      } else {
-        return entries
-      }
-    })
-    .then(function (entries) {
-      debug('qrlCache.getQnameUrlPairs.then')
-      if (options.verbose) {
-        console.error(chalk.blue('  done'))
-        console.error()
+export async function listen (queues, options) {
+  const opt = getOptionsWithDefaults(options)
+  debug({ opt, options })
+  // Function to listen to all queues in order
+  async function oneRound (queues) {
+    const stats = { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 }
+    for (const { qname, qrl } of queues) {
+      if (shutdownRequested) return stats
+      if (opt.verbose) {
+        console.error(
+          chalk.blue('Looking for work on ') +
+          qname.slice(opt.prefix.length) +
+          chalk.blue(' (' + qrl + ')')
+        )
       }
+      // Aggregate the results
+      const { noJobs, jobsSucceeded, jobsFailed } = await pollForJobs(qname, qrl, opt)
+      stats.noJobs += noJobs
+      stats.jobsFailed += jobsFailed
+      stats.jobsSucceeded += jobsSucceeded
+    }
+    return stats
+  }
 
-      // Don't listen to fail queues... unless user wants to
-      entries = entries
-        .filter(function (entry) {
-          const suf = options['fail-suffix'] + (options.fifo ? '.fifo' : '')
-          return options['include-failed'] ? true : entry.qname.slice(-suf.length) !== suf
-        })
+  // Start processing
+  if (opt.verbose) console.error(chalk.blue('Resolving queues: ') + queues.join(' '))
+  const qnames = queues.map(queue => normalizeQueueName(queue, opt))
+  const pairs = await getQnameUrlPairs(qnames, opt)
 
-      // Listen to all queues once
-      function oneRound () {
-        var result = Q()
-        entries.forEach(function (entry) {
-          debug('entries.forEach.funtion')
-          result = result.then((soFar = { noJobs: 0, jobsSucceeded: 0, jobsFailed: 0 }) => {
-            debug('soFar', soFar)
-            // Don't poll the next queue if shutdown was requested
-            if (shutdownRequested) return Promise.resolve(soFar)
-            if (options.verbose) {
-              console.error(
-                chalk.blue('Looking for work on ') +
-                entry.qname.slice(options.prefix.length) +
-                chalk.blue(' (' + entry.qrl + ')')
-              )
-            }
-            // Aggregate the results
-            return pollForJobs(entry.qname, entry.qrl, options)
-              .then(({ noJobs, jobsSucceeded, jobsFailed }) => ({
-                noJobs: soFar.noJobs + noJobs,
-                jobsSucceeded: soFar.jobsSucceeded + jobsSucceeded,
-                jobsFailed: soFar.jobsFailed + jobsFailed
-              }))
-          })
-        })
-        return result
-      }
+  // Figure out which pairs are active
+  const activePairs = []
+  if (opt.activeOnly) {
+    debug({ pairsBeforeCheck: pairs })
+    await Promise.all(pairs.map(async pair => {
+      const { idle } = await cheapIdleCheck(pair.qname, pair.qrl, opt)
+      if (!idle) activePairs.push(pair)
+    }))
+  }
 
-      // But only if we have queues to listen on
-      if (entries.length) {
-        if (options.verbose) {
-          console.error(chalk.blue('Listening to queues (in this order):'))
-          console.error(entries.map(function (e) {
-            return '  ' + e.qname.slice(options.prefix.length) + chalk.blue(' - ' + e.qrl)
-          }).join('\n'))
-          console.error()
-        }
-        return oneRound()
-      }
+  // Finished resolving
+  debug('getQnameUrlPairs.then')
+  if (opt.verbose) {
+    console.error(chalk.blue('  done'))
+    console.error()
+  }
 
-      // Otherwise, let caller know
-      return Promise.resolve('noQueues')
+  // Figure out which queues we want to listen on, choosing between active and
+  // all, filtering out failed queues if the user wants that
+  const selectedPairs = (opt.activeOnly ? activePairs : pairs)
+    .filter(({ qname }) => {
+      const suf = opt.failSuffix + (opt.fifo ? '.fifo' : '')
+      const isFailQueue = qname.slice(-suf.length) === suf
+      const shouldInclude = opt.includeFailed ? true : !isFailQueue
+      return shouldInclude
     })
+
+  // But only if we have queues to listen on
+  if (selectedPairs.length) {
+    if (opt.verbose) {
+      console.error(chalk.blue('Listening to queues (in this order):'))
+      console.error(selectedPairs.map(({ qname, qrl }) =>
+        '  ' + qname.slice(opt.prefix.length) + chalk.blue(' - ' + qrl)
+      ).join('\n'))
+      console.error()
+    }
+    return oneRound(selectedPairs)
+  }
+
+  // Otherwise, let caller know
+  return 'noQueues'
 }
 
 debug('loaded')

package/.coveralls.yml

@@ -1 +0,0 @@
-service_name: travis-ci

package/.travis.yml

@@ -1,19 +0,0 @@
-
-language: node_js
-services:
-  - redis-server
-node_js:
-  - '6'
-  - '8'
-  - '10'
-cache:
-  directories:
-    - node_modules
-after_success: npm run coverage
-
-# Trigger a push build on master and greenkeeper branches + PRs build on every branches
-# Avoid double build on PRs (See https://github.com/travis-ci/travis-ci/issues/1147)
-branches:
-  only:
-    - master
-    - /^greenkeeper.*$/

package/CHANGELOG.md

@@ -1,121 +0,0 @@
-# Changelog
-
-v.1.7.0
--------
-
-### New Features
-
-#### Added `--deduplication-id` option for enqueue ([#40](https://github.com/suredone/qdone/issues/40))
-
-`qdone` has always set a deduplication id (using a UUID v1) when sending enqueue calls, but it looks like the aws sdk does not have adequate retry defaults set. This option lets a qdone user retry enqueue operations. For more information please see the [AWS docs for Message Deduplication ID](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/using-messagededuplicationid-property.html).
-
-### Under the hood
-
-- Updated aws-sdk.
-- Updated locked dependencies.
-
-v.1.6.0
--------
-
-### New Features
-
-#### Caching for SQS `GetQueueAttributes` calls ([#41](https://github.com/suredone/qdone/issues/41))
-
-After switching our infrastructure to `--active-only` on jobs that have a large number of dynamic queues, we noticed that spend a lot of money on GetQueueAttributes calls. However the state of the active queues is very cacheable, especially if queues tend to have large backlogs, as ours do.
-
-We added the following options to the `idle-queues`, and `worker` commands to be used in conjunction with `--active-only`:
-
-- `--cache-url` that takes a `redis://...` or a `redis-cluster://` url [no default]
-- `--cache-ttl-seconds` that takes a number of seconds [default `10`]
-- `--cache-prefix` that defines a cache key prefix [default `qdone:`]
-
-The presence of the `--cache-url` option will cause the worker to cache `GetQueueAttributes` for each queue for the specified ttl.
-
-
-v.1.5.0
--------
-
-### New Features
-
-#### Added `--group-id-per-message` option for `enqueue-batch` ([#33](https://github.com/suredone/qdone/issues/33))
-
-This option creates a new Group ID for every message in a batch, for when you want exactly once delivery, but don't care about message order.
-
-### Bug Fixes
-
-- Fixed ([#35](https://github.com/suredone/qdone/issues/35)) by making `idle-queues` pairing behavior work for FIFO queues as well as normal queues.
-
-
-v.1.4.0
--------
-
-### Bug Fixes
-
-- Fixed ([#25](https://github.com/suredone/qdone/issues/25)) bug on Linux in `worker` where child processes were not getting killed after `--kill-after` timer was reached.
-
-
-v.1.3.0
--------
-
-### New Features
-
-#### FIFO Option ([#18](https://github.com/suredone/qdone/issues/18))
-
-Added a `--fifo` and `--group-id <string>` option to `equeue` and `enqueue-batch`
-- Causes any new queues to be created as FIFO queues
-- Causes the `.fifo` suffix to be appended to any queue names that do not explicitly have them
-- Causes failed queues to take the form `${name}_failed.fifo`
-- Any commands with the same `--group-id` will be worked on in the order they were received by SQS (see [FIFO docs](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/FIFO-queues.html))
-- If you don't set `--group-id` it defaults to a unique id per call to `qdone`, so this means messages sent by `enqueue-batch` will always be ordered as you sent them.
-- There is NO option to set group id per-message in `enqueue-batch`. Adding this feature in the future will change the format of the batch input file.
-- There is NO support right now for Content Deduplication, however a Unique Message Deduplication ID is generated for each command, so retry-able errors should not result in duplicate messages.
-
-Added a `--fifo` option to `worker`
-- Causes the `.fifo` suffix to be appended to any queue names that do not explicitly have them
-- When wildcard names are specified (e.g. `test_*` or `*`), worker only listens to queues with a `.fifo` suffix.
-- Failed queues are still only included if `--include-failed` is set.
-- Regardless of how many workers you have, FIFO commands with the same `--group-id` will only be executed by one worker at a time.
-- There is NO support right now for only-once processing using the Receive Request Attempt ID
-
-#### Only Listen To Active Queues with `--active-only`
-
-We encountered an occasional production problem where aggressively deleting idle queues can cause the loss of a message that was sent between the idle check and the delete operation. We were using `qdone idle-queues --delete --idle-for 10`, which is much more aggressive than the default of 60 minutes.
-
-To address this, we are adding an alternate mode of operation to the worker with the new `--active-only` flag for use with wildcard (`*`) queues that does a cheap SQS API call to check whether a queue currently has waiting messages. If so, it's put into the list of queues for the current listening round. This should have the net effect of reducing the number of queues workers have to listen to (similarly to aggresive usage of `qdone idle-queues --delete`) without exposing messages to the delete race condition. For cases where idle queues still must be deleted, we recommend using a longer timeout.
-
-### Bug Fixes
-
-- Fixed ([#29](https://github.com/suredone/qdone/issues/29)) bug in `enqueue-batch` where SQS batches where command lines added up to > 256kb would not be split correctly and loop
-
-### Under the hood
-
-- Increased test coverage related to ([#29](https://github.com/suredone/qdone/issues/29))
-- Added test coverage for ([#18](https://github.com/suredone/qdone/issues/18))
-- Updated command line args libraries
-
-
-v1.2.0 (January 5, 2018)
----------------------------
-
-### Bug Fixes
-
-- [#22](https://github.com/suredone/qdone/issues/22) fixes exception deleting failed queues in paired mode when fail queue does not exist
-
-
-v1.1.0 (December 25, 2017)
------------------------------
-
-### New Features
-
-- Add experimental support for using exports in node. Exports various functions from enqueue and worker for use from node. Doesn't change the public facing interface (which is command line only).
-
-
-v1.0.0 (August 8, 2017)
---------------------------
-
-### New Features
-
-- There is a new command called [`idle-queues`](https://github.com/suredone/qdone#idle-queues-usage) which can identify queues that have had no activity for a specified period of time, and delete them, if desired.
-- Qdone's `worker` now [allows a child process to finish running](https://github.com/suredone/qdone#shutdown-behavior) before shutting down in response to a `SIGTERM` or `SIGINT`.
-- Queues are now always resolved, and the `--always-resolve` option has been removed.
-- Output to non TTYs is less chatty by default, but you can get the previous behavior by using `--verbose`, or silence output in a TTY by using `--quiet`.

package/index.js

@@ -1,6 +0,0 @@
-
-module.exports = {
-  enqueue: require('./src/enqueue'),
-  worker: require('./src/worker'),
-  cli: require('./src/cli')
-}

package/qdone

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require('./src/cli.js').run(process.argv.slice(2)).catch(_ => process.exit(1))

package/test/fixtures/test-child-kill-linux.sh

@@ -1,9 +0,0 @@
-#!/bin/bash
-OUTFILE=/tmp/qdone-test-child-kill-linux.out
-rm $OUTFILE
-_term() { 
-  echo "terminated" > $OUTFILE
-  exit 1
-}
-trap _term SIGTERM
-for i in 1 2 3; do sleep 1; echo $i; echo $i >> $OUTFILE; done

package/test/fixtures/test-fifo01-x24.batch

@@ -1,24 +0,0 @@
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true
-test.fifo true