feat: add tree.sync and lookup.sync

Author: antongolub

README.md

@@ -7,7 +7,7 @@
 * [x] CJS and ESM package entry points
 * [x] `table-parser` replaced with `@webpod/ingrid` to handle some issues: [neekey/ps#76](https://github.com/neekey/ps/issues/76), [neekey/ps#62](https://github.com/neekey/ps/issues/62), [neekey/table-parser#11](https://github.com/neekey/table-parser/issues/11), [neekey/table-parser#18](https://github.com/neekey/table-parser/issues/18)
 * [x] Provides promisified responses
-* [ ] Brings sync API
+* [x] Brings sync API
 * [x] Builds a process tree
 
 ## Install
@@ -44,6 +44,9 @@ lookup({pid: 12345}, (err, list) => {
     console.log('No such process found!')
   }
 })
+
+// or syncronously
+const _list = lookup.sync({pid: 12345})
 ```
 
 Define a query opts to filter the results by `command` and/or `arguments` predicates:
@@ -109,6 +112,9 @@ const children = await tree({pid: 123, recursive: true})
   {pid: 130, ppid: 125},
 ] 
 */
+
+// or syncronously
+const list = tree.sync({pid: 123, recursive: true}) 
 ```
 
 ### kill()

package-lock.json

@@ -1,8 +1,8 @@
 import process from 'node:process'
 import fs from 'node:fs'
+import { EOL as SystemEOL } from 'node:os'
 import { parse, TIngridResponse } from '@webpod/ingrid'
 import { exec, TSpawnCtx } from 'zurk/spawn'
-import { EOL as SystemEOL } from 'node:os'
 
 const EOL = /(\r\n)|(\n\r)|\n|\r/
 const IS_WIN = process.platform === 'win32'
@@ -46,44 +46,76 @@ export type TPsNext = (err?: any, data?: any) => void
  * @param {String} query.command RegExp String
  * @param {String} query.arguments RegExp String
  * @param {String|String[]} query.psargs
- * @param {Function} cb
+ * @param {Function} [cb]
+ * @param {Object=null} cb.err
+ * @param {TPsLookupEntry[]} cb.processList
+ * @return {Promise<TPsLookupEntry[]>}
+ */
+export const lookup = (query: TPsLookupQuery = {}, cb: TPsLookupCallback = noop): Promise<TPsLookupEntry[]> =>
+  _lookup({query, cb, sync: false})
+
+/**
+ * Looks up the process list synchronously
+ * @param query
+ * @param {String|String[]} query.pid
+ * @param {String} query.command RegExp String
+ * @param {String} query.arguments RegExp String
+ * @param {String|String[]} query.psargs
+ * @param {Function} [cb]
  * @param {Object=null} cb.err
  * @param {Object[]} cb.processList
- * @return {Object}
+ * @return {TPsLookupEntry[]}
  */
-export const lookup = (query: TPsLookupQuery = {}, cb: TPsLookupCallback = noop) => {
-  const { promise, resolve, reject } = makeDeferred<TPsLookupEntry[]>()
+export const lookupSync = (query: TPsLookupQuery = {}, cb: TPsLookupCallback = noop): TPsLookupEntry[] =>
+  _lookup({query, cb, sync: true})
+
+lookup.sync = lookupSync
+
+const _lookup = ({
+    query = {},
+    cb = noop,
+    sync = false
+  }: {
+    sync?: boolean
+    cb?: TPsLookupCallback
+    query?: TPsLookupQuery
+  }) => {
+  const pFactory = sync ? makePseudoDeferred.bind(null, []) : makeDeferred
+  const { promise, resolve, reject } = pFactory()
   const { psargs = ['-lx'] } = query // add 'lx' as default ps arguments, since the default ps output in linux like "ubuntu", wont include command arguments
-  const args = typeof psargs === 'string' ? psargs.split(/\s+/) : psargs
+  const args = Array.isArray(psargs) ? psargs : psargs.split(/\s+/)
   const extract = IS_WIN ? extractWmic : identity
+
+  let result: TPsLookupEntry[] = []
   const callback: TSpawnCtx['callback'] = (err, {stdout}) => {
     if (err) {
       reject(err)
       cb(err)
       return
     }
-
-    const list = parseProcessList(extract(stdout), query)
-    resolve(list)
-    cb(null, list)
+    result = parseProcessList(extract(stdout), query)
+    resolve(result)
+    cb(null, result)
   }
   const ctx: TSpawnCtx = IS_WIN
     ? {
       cmd: 'cmd',
       input: 'wmic process get ProcessId,ParentProcessId,CommandLine \n',
       callback,
+      sync,
       run(cb) {cb()}
     }
     : {
       cmd: 'ps',
       args,
       run(cb) {cb()},
+      sync,
       callback,
     }
 
   exec(ctx)
 
-  return promise
+  return Object.assign(promise, result)
 }
 
 export const parseProcessList = (output: string, query: TPsLookupQuery = {}) => {
@@ -128,26 +160,45 @@ export const pickTree = (list: TPsLookupEntry[], pid: string | number, recursive
   ]
 }
 
-export const tree = async (opts?: string | number | TPsTreeOpts | undefined, cb: TPsLookupCallback = noop): Promise<TPsLookupEntry[]> => {
+const _tree = ({
+  cb = noop,
+  opts,
+  sync = false
+}: {
+  opts?: string | number | TPsTreeOpts | undefined
+  cb?: TPsLookupCallback
+  sync?: boolean
+}): any => {
   if (typeof opts === 'string' || typeof opts === 'number') {
-    return tree({ pid: opts }, cb)
+    return _tree({opts: {pid: opts}, cb, sync})
   }
-
-  try {
-    const all = await lookup()
+  const handle = (all: TPsLookupEntry[]) => {
     if (opts === undefined) return all
 
     const {pid, recursive = false} = opts
     const list = pickTree(all, pid, recursive)
 
     cb(null, list)
     return list
+  }
+
+  try {
+    const all = _lookup({sync})
+    return sync ? handle(all) : all.then(handle)
   } catch (err) {
     cb(err)
     throw err
   }
 }
 
+export const tree = async (opts?: string | number | TPsTreeOpts | undefined, cb?: TPsLookupCallback): Promise<TPsLookupEntry[]> =>
+  _tree({opts, cb})
+
+export const treeSync = (opts?: string | number | TPsTreeOpts | undefined, cb?: TPsLookupCallback): TPsLookupEntry[] =>
+  _tree({opts, cb, sync: true})
+
+tree.sync = treeSync
+
 /**
  * Kill process
  * @param pid
@@ -253,13 +304,23 @@ export const formatOutput = (data: TIngridResponse): TPsLookupEntry[] =>
 
 export type PromiseResolve<T = any> = (value?: T | PromiseLike<T>) => void
 
-export const makeDeferred = <T = any, E = any>(): { promise: Promise<T>, resolve: PromiseResolve<T>, reject: PromiseResolve<E> } => {
+const makeDeferred = <T = any, E = any>(): { promise: Promise<T>, resolve: PromiseResolve<T>, reject: PromiseResolve<E> } => {
   let resolve
   let reject
   const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej })
   return { resolve, reject, promise } as any
 }
 
-export const noop = () => {/* noop */}
+const makePseudoDeferred = <T = any, E = any>(r = {}): { promise: any, resolve: any, reject: any } => {
+  return {
+    promise: r as any,
+    resolve: identity,
+    reject(e: any) {
+      throw e
+    }
+  }
+}
+
+const noop = () => {/* noop */}
 
-export const identity = <T>(v: T): T => v
+const identity = <T>(v: T): T => v

src/main/ts/ps.ts

@@ -3,7 +3,7 @@ import { describe, it, before, after } from 'node:test'
 import process from 'node:process'
 import * as cp from 'node:child_process'
 import * as path from 'node:path'
-import { kill, lookup, tree } from '../../main/ts/ps.ts'
+import { kill, lookup, lookupSync, tree, treeSync } from '../../main/ts/ps.ts'
 
 const __dirname = new URL('.', import.meta.url).pathname
 const marker = Math.random().toString(16).slice(2)
@@ -43,6 +43,27 @@ describe('lookup()', () => {
   })
 })
 
+describe('lookupSync()', () => {
+  let pid: number
+  before(() => {
+    pid = cp.fork(testScript, testScriptArgs).pid as number
+  })
+
+  after(() => {
+    try {
+      process.kill(pid)
+    } catch (err) { void err }
+  })
+
+  it('returns a process list', () => {
+    const list = lookupSync()
+    assert.ok(list.length > 0)
+  })
+  it('lookup.sync refs to lookupSync', () => {
+    assert.equal(lookup.sync, lookupSync)
+  })
+})
+
 describe('kill()', () => {
   it('kills a process', async () => {
     const pid = cp.fork(testScript, testScriptArgs).pid as number
@@ -89,3 +110,27 @@ describe('tree()', () => {
     assert.ok(list.length > 0)
   })
 })
+
+describe('treeSync()', () => {
+  it('tree.sync refs to treeSync', () => {
+    assert.equal(tree.sync, treeSync)
+  })
+
+  it('returns 1st level child', async () => {
+    const pid = cp.fork(testScript, [...testScriptArgs, '--fork=1', '--depth=2']).pid as number
+    await new Promise(resolve => setTimeout(resolve, 2000)) // wait for child process to spawn
+
+    const list = lookupSync({ arguments: marker })
+    const children = treeSync(pid)
+    const childrenAll =  treeSync({pid, recursive: true})
+
+    await Promise.all(list.map(p => kill(p.pid)))
+    await kill(pid)
+
+    assert.equal(children.length, 1)
+    assert.equal(childrenAll.length, 2)
+    assert.equal(list.length, 3)
+
+    assert.equal((await lookup({ arguments: marker })).length, 0)
+  })
+})