the-shepherd

#!/usr/bin/env node $ = require 'bling' Shell = require 'shelljs' Process = module.exports log = $.logger "[Process]" Process.exec = (cmd, verbose) -> try return p = $.Promise() finally try if verbose then log "shell >", cmd ret = { output: "" } child = Shell.exec cmd, { silent: true, async: true }, (exitCode) -> try if exitCode isnt 0 then p.reject ret.output else p.resolve ret.output catch err log "exec: error handling process exit:", err.stack ? err child.stdout.on "data", append_output = (data) -> ret.output += String data child.stderr.on "data", append_output catch err log "exec: error in running process:", err.stack ? err # for caching the output of 'ps' commands # mostly to save time in commands like Process.tree # where possibly hundreds of Process.find calls are generated. psCache = new $.Cache(2, 100) ps_cmd = "ps -eo uid,pid,ppid,pcpu,rss,command" ps_parse = (output) -> try output = output.split('\n').map((line) -> # split into lines line.split(/[ ]+/).slice(1) # split each line on whitespace ).slice(0,-1) # discard the last line? # turn the 2D array of proc data into a list of process objects keys = output[0].map $.slugize # parse the first line for the field names return output.slice(1).map (row) -> # for each row try return ret = Object.create(null) # return an object finally for key,i in keys # attach an output value to each key for this row if i is keys.length - 1 # the last value (the command) is all concatenated together ret[key] = row.slice(i).join(' ') else val = row[i] try # gently attempt to make numbers out of number-like strings val = parseInt(val, 10) unless isFinite(val) # revert the value on a soft parsing (NaN, Infinity, etc) val = row[i] catch e val = row[i] finally ret[key] = val unless ret[key]? log "ps_parse failed to parse line:", key, i, row[i], ret[key] catch err log "ps_parse error:", err.stack ? err # given the output of ps_parse, use "lsof" to attach listening ports lsof_cmd = "lsof -Pni | grep LISTEN" attach_ports = (procs) -> try return attached = $.Promise() finally try index = Object.create null for proc in procs index[proc.pid] = proc proc.ports = [] Process.exec(lsof_cmd).then (output) -> try for line in output.split /\n/g line = line.split(/\s+/g) continue if line.length < 8 pid = parseInt line[1], 10 port = parseInt line[8].split(/:/)[1], 10 unless pid of index index[pid] = { pid: pid, ports: [] } try index[pid].ports.push port catch err log err, pid, index[pid] attached.resolve(procs) catch err log "attach_ports error while parsing output:", err.stack ? err catch err log "attach_ports error:", err.stack ? err Process.clearCache = -> psCache.del ps_cmd; Process Process.find = (query) -> try return p = $.Promise() finally try query = switch $.type query when "string" then { cmd: new RegExp query } when "number" then { pid: query } else query if psCache.has ps_cmd p.resolve psCache.get(ps_cmd).filter (item) -> $.matches query, item else Process.exec(ps_cmd).then ((output) -> attach_ports(ps_parse(output)).then ((procs) -> try p.resolve psCache.set(ps_cmd, procs).filter (item) -> $.matches query, item catch err log "find error in results:", err.stack ? err ), p.reject ), p.reject catch err log "find error:", err.stack ? err Process.findOne = (query) -> try return p = $.Promise() finally Process.find(query).then ((out) -> try p.resolve out[0] catch err then log "findOne error:", err.stack ? err ), p.reject Process.findTree = (query) -> try return p = $.Promise() finally Process.findOne(query).then (proc) -> Process.tree(proc).then p.resolve, p.reject Process.signals = signals = { SIGHUP: 1 SIGINT: 2 SIGKILL: 9 SIGTERM: 15 HUP: 1 INT: 2 KILL: 9 TERM: 15 } Process.getSignalNumber = (signal) -> signals[signal] ? (if $.is 'number', signal then signal else 15) Process.kill = (pid, signal) -> try Process.exec "kill -#{Process.getSignalNumber signal} #{pid}" catch err then log "kill error:", err.stack ? err Process.tree = (proc) -> try return q = $.Promise() finally p = $.Progress 1 if proc then Process.find({ ppid: proc.pid }).then ((children) -> try proc.children = children for child in children p.include Process.tree child p.resolve(1, proc) catch err log "tree error:", err.stack ? err ), q.reject p.then (-> q.resolve proc), q.reject Process.walk = (node, visit, depth=0) -> try return p = $.Progress(1) finally try p.include visit node, depth catch err log "walk error (in visit):", err.stack ? err p.reject err for child in node.children p.include Process.walk child, visit, depth + 1 p.finish(1) Process.killTree = (proc, signal) -> try return p = $.Promise() finally try signal = Process.getSignalNumber(signal) proc = switch $.type proc when 'string','number' then { pid: proc } else proc tokill = [] fail = (msg, err) -> log msg, err?.stack ? err p.reject err Process.tree(proc).then ((tree) -> try Process.walk tree, (node) -> if node.pid then tokill.push node.pid else fail "killTree invalid node (no pid):", node if tokill.length Process.exec("kill -#{signal} #{tokill.join ' '} &> /dev/null") .then p.resolve, (err) -> fail "killTree error while killing", err catch err then fail "killTree error while walking:", err ), p.reject catch err then fail "killTree error:", err Process.summarize = (proc) -> # currently kind of worthless, needs to use depth proc.rss = proc.cpu = 0 try return p = $.Promise() finally Process.tree(proc).then (tree) -> Process.walk tree, (node, depth) -> proc.rss += node.rss # sum values upwards proc.cpu += node.cpu p.resolve tree Process.printTree = (proc, indent, spacer) -> try spacer or= " \\_" indent or= "* " ret = indent + proc.pid + " " + proc.command if proc.ports?.length then ret += " [:" + proc.ports.join(", :") + "]" ret += " {mem: #{$.commaize proc.rss}kb cpu: #{proc.cpu}%}\n" indent = spacer + indent for child in proc.children ret += Process.printTree child, indent, " " indent.replace /^ /,'' return ret catch err log "printTree error:", err.stack ? err if require.main is module port = parseInt(process.argv[2], 10) || 8000 log "Tree for owner of:", port Process.find({ ports: port }).then (procs) -> for proc in procs Process.tree(proc).then (tree) -> console.log Process.printTree tree