¿Cómo elimino procesos anteriores a "t"?

Primero, sí, he visto esta pregunta:

Encuentra (y elimina) procesos antiguos

Las respuestas allí son incorrectas y no funcionan. He votado y comentado en consecuencia.

Los procesos que quiero matar se ven así cuando se enumeran con ps aux | grep page.py:

apache 424 0.0 0.1 6996 4564? S 07:02 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 2686 0.0 0.1 7000 3460? S Sep10 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 2926 0.0 0.0 6996 1404? S Sep02 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 7398 0.0 0.0 6996 1400? S Sep01 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 9423 0.0 0.1 6996 3824? S Sep10 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 11022 0.0 0.0 7004 1400? S Sep01 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 15343 0.0 0.1 7004 3788? S Sep09 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 15364 0.0 0.1 7004 3792? S Sep09 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 15397 0.0 0.1 6996 3788? S Sep09 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 16817 0.0 0.1 7000 3788? S Sep09 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 17590 0.0 0.0 7000 1432? S Sep07 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 24448 0.0 0.0 7000 1432? S Sep07 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py
apache 30361 0.0 0.1 6996 3776? S Sep09 0:00 /usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py

Estoy buscando configurar un cron diario simple que encuentre y elimine los page.pyprocesos anteriores a una hora.

La respuesta aceptada en la pregunta antes mencionada no funciona, ya que no coincide con un rango de veces, simplemente coincide con los procesos que se han estado ejecutando de 7 días a 7 días 23 horas 59 minutos y 59 segundos. No quiero matar los procesos que se han estado ejecutando de 1 a 2 horas, sino más de 1 hora.

La otra respuesta a la pregunta anterior usando findno funciona, al menos no en Gentoo o CentOS 5.4, o escupe una advertencia o no devuelve nada si se sigue el consejo de dicha advertencia.

GNU Killall puede matar procesos anteriores a una edad determinada, utilizando su nombre de proceso.

if [[ "$(uname)" = "Linux" ]];then killall --older-than 1h page.py;fi

Gracias a la respuesta de Christopher pude adaptarlo a lo siguiente:

find /proc -maxdepth 1 -user apache -type d -mmin +60 -exec basename {} \; \
| xargs ps | grep page.py | awk '{ print $1 }' | sudo xargs kill

-mmin fue el comando de encontrar que me faltaba.

find no siempre funciona, no todos los sistemas tienen ediciones disponibles, y podría ser mi estado regex newb, pero no creo que necesite nada más que esto:

ps -eo pid,etimes,comm,user,tty | awk '{if ($4 ~ /builder/ && $5 ~ /pts/ && $2>600) print $1}'

• enumere todos los procesos y proporcione columnas PID, ELAPSED (etimes = segundos), COMMAND, USER, TT (gracias @ahoffman)
• con awk imprime el PID donde la 4ta columna ($ 4, USUARIO) contiene texto 'constructor', y la 5ta columna ($ 5, TT) contiene texto 'pts' y la columna ELAPSED tiene un valor mayor de 600 segundos (gracias @amtd)

entonces puedes canalizar eso para matar o lo que sea que necesites.

# get elapsed time in seconds, filter our only those who >= 3600 sec
ps axh -O etimes  | awk '{if ($2 >= 3600) print $2}'

Si lo desea, puede alimentar pscon una lista de PID para buscar, por ejemplo:

ps h -O etimes 1 2 3

Creo que puede modificar algunas de esas respuestas anteriores para satisfacer sus necesidades. A saber:

para FILE in (find. -maxdepth 1 -user processuser -type d -mmin +60)
  do kill -9 $ (basename $ FILE) # Nunca puedo hacer que basename trabaje con el exec de find. ¡Avísame si sabes cómo!
hecho

O

ps -eo pid, etime, comm | awk '$ 2! ~ /^..:..$/ && $ 3 ~ / page \ .py / {print $ 1}' | matar -9

Creo que el segundo puede ajustarse mejor a tus necesidades. La versión de búsqueda terminaría destruyendo otros procesos de ese usuario:


Christopher Karel

apt-get install psmisc

killall -o 1h $proc_name

El problema

Convertir la etimecolumna de pscomando (tiempo transcurrido) a segundos. La especificación de tiempo está en este formato [[dd-]hh:]mm:ss. Las versiones más nuevas de pstienen una etimescolumna que genera etimevalor en segundos.

La solución: función awk personalizada simple

Esta función awk personalizada admite todos los formatos de etimecolumna (p 03-12:30:59. Ej. , 00:07Etc.). Simplemente péguelo en su script awk, es una solución amigable.

function sec(T){C=split(T,A,"[:-]"); return A[C>3?C-3:99]*86400 + A[C>2?C-2:99]*3600 + A[C>1?C-1:99]*60 + A[C>0?C-0:99]*1}

• sec(T) convierte T a segundos
• Tespecificación de tiempo en [[dd-]hh:]mm:ssformato (p etime. ej. )
• Crecuento de campos en T(equivalente a la variable NF de awk)
• Amatriz de campos en T(equivalente a la variable $ de awk)
• A[C>3?C-3:99]Esta es una forma segura de hacer referencia al cuarto valor (es decir, número de días) en orden inverso. Este enfoque es útil porque los días y las horas son opcionales. Si la matriz no es lo suficientemente larga, desreferenciará A[99]lo que arrojará 0valor. Supongo que 99es lo suficientemente alto para la mayoría de los casos de uso.
• devuelve segundos como entero

Ejemplo del mundo real

Este bash oneliner matará el soffice.binproceso que se ejecuta bajo el usuario actual si el proceso es anterior a 180 segundos.

kill -9 $(ps cx -o command,etime,pid | awk '/^soffice.bin/ {if (sec($2)>180) {print $3}} function sec(T){C=split(T,A,"[:-]"); return A[C>3?C-3:99]*86400 + A[C>2?C-2:99]*3600 + A[C>1?C-1:99]*60 + A[C>0?C-0:99]*1}')

El lstartcampo en psda un formato de tiempo consistente que podemos alimentar datepara convertir a segundos desde la época. Luego solo comparamos eso con la hora actual.

#!/bin/bash
current_time=$(date +%s)
ps axo lstart=,pid=,cmd= |
    grep page.py |
    while read line
    do
        # 60 * 60 is one hour, multiply additional or different factors for other thresholds 
        if (( $(date -d "${line:0:25}" +%s) < current_time - 60 * 60 ))
        then
            echo $line | cut -d ' ' -f 6    # change echo to kill
        fi
    done

Modifiqué la respuesta que te dieron en la publicación anterior

ps -eo pid,etime,comm | 
egrep '^ *[0-9]+ +([0-9]+-[^ ]*|[0-9]{2}:[0-9]{2}:[0-9]{2}) +/usr/bin/python2.6 /u/apps/pysnpp/current/bin/page.py' | 
awk '{print $1}' | 
xargs kill

La expresión regular busca 2 tipos de segundo argumento:

• Días en forma de dígitos y un signo menos.
• Hours:minutes:seconds expresión.

Eso debería coincidir con todo, excepto los procesos jóvenes que tendrían la forma minutes:seconds.

Esto probablemente sea excesivo, pero tuve la curiosidad de terminarlo y probar que funciona (en un nombre de proceso diferente en mi sistema, por supuesto). Puede eliminar la captura $usery $pidsimplificar la expresión regular, que solo agregué para la depuración, y no tenía ganas de volver a salir. Las capturas con nombre de perl 5.10 eliminarían un par de líneas más, pero esto debería funcionar en perls más antiguos.

Necesitará reemplazar la impresión con un kill, por supuesto, pero no estaba dispuesto a matar nada en mi propio sistema.

#!/usr/bin/perl -T
use strict; use warnings;

$ENV{"PATH"} = "/usr/bin:/bin";                                                       

my (undef,undef,$hour) = localtime(time);                                             
my $target = $hour - 2; # Flag process before this hour                               
my $grep = 'page.py';                                                   

my @proclist = `ps -ef | grep $grep`;                                                 
foreach my $proc (@proclist)                                                          
{                                                                                     
    $proc =~ /(\w+)\s+(\d+)\s+\d+\s+\d+\s+(.*?).*/;                   
    my $user = $1;                                                                    
    my $pid = $2;                                                                     
    my $stime = $3;                                                                   

    $stime =~ s/(\d+):(\d+)/$1/;                                                      

    # We're going to do a numeric compare against strings that                        
    # potentially compare things like 'Aug01' when the STIME is old                   
    # enough.  We don't care, and we want to catch those old pids, so                 
    # we just turn the warnings off inside this foreach.                              
    no warnings 'numeric';                                                            

    unless ($stime > $target)                                                         
    {                                                                                 
        print "$pid\n";                                                               
    }                                                                                 
}

Tengo un servidor con fechas incorrectas en / proc y find no funciona, así que escribí este script:

#!/bin/bash

MAX_DAYS=7  #set the max days you want here
MAX_TIME=$(( $(date +'%s') - $((60*60*24*$MAX_DAYS)) ))

function search_and_destroy()
{
        PATTERN=$1
        for p in $(ps ux|grep "$PATTERN"|grep -v grep| awk '{ print $2 }')
        do
            test $(( $MAX_TIME - $(date -d "`ps -p $p -o lstart=`" +'%s') )) -ge 0 && kill -9 $p
        done
}

search_and_destroy " command1 "
search_and_destroy " command2 "

Versión de Python usando el ctime de las entradas de proceso en /proc:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# kills processes older than HOURS_DELTA hours

import os, time

SIGNAL=15
HOURS_DELTA=1

pids = [int(pid) for pid in os.listdir('/proc') if pid.isdigit()]

for pid in pids:
    if os.stat(os.path.join('/proc', str(pid))).st_ctime < time.time() - HOURS_DELTA * 3600:
        try:
            os.kill(pid, SIGNAL)
        except:
            print "Couldn't kill process %d" % pid

Utilizo este script simple, toma dos argumentos: nombre del proceso y antigüedad en segundos.

#!/bin/bash
# first argument name of the process to check
# second argument maximum age in seconds
# i.e kill lighttpd after 5 minutes
#   script.sh lighttpd 300 
process=$1
maximum_runtime=$2
pid=`pgrep $process`
if [ $? -ne 0 ]
then
        exit 0
fi
process_start_time=`stat /proc/$pid/cmdline --printf '%X'`
current_time=`date +%s`
let diff=$current_time-$process_start_time

if [ $diff -gt $maximum_runtime ]
then
        kill -3 $pid
fi

Esto debería funcionar

killall --older-than 1h $proc_name

No estaba satisfecho con la otra solución, la mayoría de ellos son demasiado crípticos (mi conocimiento básico es un poco limitado) y, por lo tanto, no puedo personalizarlos ...
He creado mi propia solución. Probablemente no sea la mejor, pero funciona y es legible

Puede guardar este script en un archivo y hacerlo ejecutable (eventualmente llamarlo con el uso de cron)

#!/bin/bash
## time in second that trigger the kill
LIMIT=10
## [] skip the grep from the process list
PROC_NAME="[m]y process name"
## etimes return the time in seconds
TIME_SEC=$(ps axo etimes,pid,command | grep "$PROC_NAME" | awk {'print$1'})
PID=$(ps axo etimes,pid,command | grep "$PROC_NAME" | awk {'print$2'})

if [ -n "$TIME_SEC" ] 
    then
    if (( $TIME_SEC > $LIMIT )); then
        kill $PID
    fi
fi

72 = 3 días 48 = 2 días 24 = 1 día

a1=$(TZ=72 date +%d) ps -ef| cat filex.txt | sed '/[JFMASOND][aepuco][nbrylgptvc] '$a1'/!d' | awk '{ print $2 " " $5 " " $6 }' > file2.txt

funciona :)