1 #!/usr/bin/env python 2 3 import os 4 import re 5 import sys 6 7 def _write_message(kind, message): 8 import inspect, os, sys 9 10 # Get the file/line where this message was generated. 11 f = inspect.currentframe() 12 # Step out of _write_message, and then out of wrapper. 13 f = f.f_back.f_back 14 file,line,_,_,_ = inspect.getframeinfo(f) 15 location = '%s:%d' % (os.path.basename(file), line) 16 17 print >>sys.stderr, '%s: %s: %s' % (location, kind, message) 18 19 note = lambda message: _write_message('note', message) 20 warning = lambda message: _write_message('warning', message) 21 error = lambda message: (_write_message('error', message), sys.exit(1)) 22 23 def re_full_match(pattern, str): 24 m = re.match(pattern, str) 25 if m and m.end() != len(str): 26 m = None 27 return m 28 29 def parse_time(value): 30 minutes,value = value.split(':',1) 31 if '.' in value: 32 seconds,fseconds = value.split('.',1) 33 else: 34 seconds = value 35 return int(minutes) * 60 + int(seconds) + float('.'+fseconds) 36 37 def extractExecutable(command): 38 """extractExecutable - Given a string representing a command line, attempt 39 to extract the executable path, even if it includes spaces.""" 40 41 # Split into potential arguments. 42 args = command.split(' ') 43 44 # Scanning from the beginning, try to see if the first N args, when joined, 45 # exist. If so that's probably the executable. 46 for i in range(1,len(args)): 47 cmd = ' '.join(args[:i]) 48 if os.path.exists(cmd): 49 return cmd 50 51 # Otherwise give up and return the first "argument". 52 return args[0] 53 54 class Struct: 55 def __init__(self, **kwargs): 56 self.fields = kwargs.keys() 57 self.__dict__.update(kwargs) 58 59 def __repr__(self): 60 return 'Struct(%s)' % ', '.join(['%s=%r' % (k,getattr(self,k)) 61 for k in self.fields]) 62 63 kExpectedPSFields = [('PID', int, 'pid'), 64 ('USER', str, 'user'), 65 ('COMMAND', str, 'command'), 66 ('%CPU', float, 'cpu_percent'), 67 ('TIME', parse_time, 'cpu_time'), 68 ('VSZ', int, 'vmem_size'), 69 ('RSS', int, 'rss')] 70 def getProcessTable(): 71 import subprocess 72 p = subprocess.Popen(['ps', 'aux'], stdout=subprocess.PIPE, 73 stderr=subprocess.PIPE) 74 out,err = p.communicate() 75 res = p.wait() 76 if p.wait(): 77 error('unable to get process table') 78 elif err.strip(): 79 error('unable to get process table: %s' % err) 80 81 lns = out.split('\n') 82 it = iter(lns) 83 header = it.next().split() 84 numRows = len(header) 85 86 # Make sure we have the expected fields. 87 indexes = [] 88 for field in kExpectedPSFields: 89 try: 90 indexes.append(header.index(field[0])) 91 except: 92 if opts.debug: 93 raise 94 error('unable to get process table, no %r field.' % field[0]) 95 96 table = [] 97 for i,ln in enumerate(it): 98 if not ln.strip(): 99 continue 100 101 fields = ln.split(None, numRows - 1) 102 if len(fields) != numRows: 103 warning('unable to process row: %r' % ln) 104 continue 105 106 record = {} 107 for field,idx in zip(kExpectedPSFields, indexes): 108 value = fields[idx] 109 try: 110 record[field[2]] = field[1](value) 111 except: 112 if opts.debug: 113 raise 114 warning('unable to process %r in row: %r' % (field[0], ln)) 115 break 116 else: 117 # Add our best guess at the executable. 118 record['executable'] = extractExecutable(record['command']) 119 table.append(Struct(**record)) 120 121 return table 122 123 def getSignalValue(name): 124 import signal 125 if name.startswith('SIG'): 126 value = getattr(signal, name) 127 if value and isinstance(value, int): 128 return value 129 error('unknown signal: %r' % name) 130 131 import signal 132 kSignals = {} 133 for name in dir(signal): 134 if name.startswith('SIG') and name == name.upper() and name.isalpha(): 135 kSignals[name[3:]] = getattr(signal, name) 136 137 def main(): 138 global opts 139 from optparse import OptionParser, OptionGroup 140 parser = OptionParser("usage: %prog [options] {pid}*") 141 142 # FIXME: Add -NNN and -SIGNAME options. 143 144 parser.add_option("-s", "", dest="signalName", 145 help="Name of the signal to use (default=%default)", 146 action="store", default='INT', 147 choices=kSignals.keys()) 148 parser.add_option("-l", "", dest="listSignals", 149 help="List known signal names", 150 action="store_true", default=False) 151 152 parser.add_option("-n", "--dry-run", dest="dryRun", 153 help="Only print the actions that would be taken", 154 action="store_true", default=False) 155 parser.add_option("-v", "--verbose", dest="verbose", 156 help="Print more verbose output", 157 action="store_true", default=False) 158 parser.add_option("", "--debug", dest="debug", 159 help="Enable debugging output", 160 action="store_true", default=False) 161 parser.add_option("", "--force", dest="force", 162 help="Perform the specified commands, even if it seems like a bad idea", 163 action="store_true", default=False) 164 165 inf = float('inf') 166 group = OptionGroup(parser, "Process Filters") 167 group.add_option("", "--name", dest="execName", metavar="REGEX", 168 help="Kill processes whose name matches the given regexp", 169 action="store", default=None) 170 group.add_option("", "--exec", dest="execPath", metavar="REGEX", 171 help="Kill processes whose executable matches the given regexp", 172 action="store", default=None) 173 group.add_option("", "--user", dest="userName", metavar="REGEX", 174 help="Kill processes whose user matches the given regexp", 175 action="store", default=None) 176 group.add_option("", "--min-cpu", dest="minCPU", metavar="PCT", 177 help="Kill processes with CPU usage >= PCT", 178 action="store", type=float, default=None) 179 group.add_option("", "--max-cpu", dest="maxCPU", metavar="PCT", 180 help="Kill processes with CPU usage <= PCT", 181 action="store", type=float, default=inf) 182 group.add_option("", "--min-mem", dest="minMem", metavar="N", 183 help="Kill processes with virtual size >= N (MB)", 184 action="store", type=float, default=None) 185 group.add_option("", "--max-mem", dest="maxMem", metavar="N", 186 help="Kill processes with virtual size <= N (MB)", 187 action="store", type=float, default=inf) 188 group.add_option("", "--min-rss", dest="minRSS", metavar="N", 189 help="Kill processes with RSS >= N", 190 action="store", type=float, default=None) 191 group.add_option("", "--max-rss", dest="maxRSS", metavar="N", 192 help="Kill processes with RSS <= N", 193 action="store", type=float, default=inf) 194 group.add_option("", "--min-time", dest="minTime", metavar="N", 195 help="Kill processes with CPU time >= N (seconds)", 196 action="store", type=float, default=None) 197 group.add_option("", "--max-time", dest="maxTime", metavar="N", 198 help="Kill processes with CPU time <= N (seconds)", 199 action="store", type=float, default=inf) 200 parser.add_option_group(group) 201 202 (opts, args) = parser.parse_args() 203 204 if opts.listSignals: 205 items = [(v,k) for k,v in kSignals.items()] 206 items.sort() 207 for i in range(0, len(items), 4): 208 print '\t'.join(['%2d) SIG%s' % (k,v) 209 for k,v in items[i:i+4]]) 210 sys.exit(0) 211 212 # Figure out the signal to use. 213 signal = kSignals[opts.signalName] 214 signalValueName = str(signal) 215 if opts.verbose: 216 name = dict((v,k) for k,v in kSignals.items()).get(signal,None) 217 if name: 218 signalValueName = name 219 note('using signal %d (SIG%s)' % (signal, name)) 220 else: 221 note('using signal %d' % signal) 222 223 # Get the pid list to consider. 224 pids = set() 225 for arg in args: 226 try: 227 pids.add(int(arg)) 228 except: 229 parser.error('invalid positional argument: %r' % arg) 230 231 filtered = ps = getProcessTable() 232 233 # Apply filters. 234 if pids: 235 filtered = [p for p in filtered 236 if p.pid in pids] 237 if opts.execName is not None: 238 filtered = [p for p in filtered 239 if re_full_match(opts.execName, 240 os.path.basename(p.executable))] 241 if opts.execPath is not None: 242 filtered = [p for p in filtered 243 if re_full_match(opts.execPath, p.executable)] 244 if opts.userName is not None: 245 filtered = [p for p in filtered 246 if re_full_match(opts.userName, p.user)] 247 filtered = [p for p in filtered 248 if opts.minCPU <= p.cpu_percent <= opts.maxCPU] 249 filtered = [p for p in filtered 250 if opts.minMem <= float(p.vmem_size) / (1<<20) <= opts.maxMem] 251 filtered = [p for p in filtered 252 if opts.minRSS <= p.rss <= opts.maxRSS] 253 filtered = [p for p in filtered 254 if opts.minTime <= p.cpu_time <= opts.maxTime] 255 256 if len(filtered) == len(ps): 257 if not opts.force and not opts.dryRun: 258 error('refusing to kill all processes without --force') 259 260 if not filtered: 261 warning('no processes selected') 262 263 for p in filtered: 264 if opts.verbose: 265 note('kill(%r, %s) # (user=%r, executable=%r, CPU=%2.2f%%, time=%r, vmem=%r, rss=%r)' % 266 (p.pid, signalValueName, p.user, p.executable, p.cpu_percent, p.cpu_time, p.vmem_size, p.rss)) 267 if not opts.dryRun: 268 try: 269 os.kill(p.pid, signal) 270 except OSError: 271 if opts.debug: 272 raise 273 warning('unable to kill PID: %r' % p.pid) 274 275 if __name__ == '__main__': 276 main() 277
