Conteggio semplice script bash in esecuzione processi per nome

Question

sto lavorando su un piccolo script bash che conta quanto spesso è in esecuzione uno script con un certo nome.

ps -ef | grep -v grep | grep scrape_data.php | wc -l 

è il codice che uso, tramite ssh emette il numero di volte scrape_data.php esegue. Ad esempio, l'output è 3 per esempio. Quindi questo funziona bene.

Ora sto cercando di fare un piccolo script che fa qualcosa quando il conteggio è minore di 1.

#!/bin/sh 


if [ ps -ef | grep -v grep | grep scrape_data.php | wc -l ] -lt 1; then 
     exit 0 

#HERE PUT CODE TO START NEW PROCESS 

else 

     exit 0 
fi 

Lo script precedente è quello che ho finora, ma non funziona. Mi viene visualizzato questo errore:

[root@s1 crons]# ./check_data.sh 
./check_data.sh: line 4: [: missing `]' 
wc: invalid option -- e 

Che cosa sto sbagliando nell'istruzione if?

Answer 1

la sintassi di prova non è corretta, il lt dovrebbe essere entro la staffa di prova:

if [ $(ps -ef | grep -v grep | grep scrape_data.php | wc -l) -lt 1 ]; then 

    echo launch 

else 
    echo no launch 

    exit 0 
fi 

o si può verificare il valore di ritorno di pgrep:

pgrep scrape_data.php &> /dev/null 

if [ $? ]; then 
    echo no launch 
fi 

Answer 2

se si sta utilizzando Bash quindi rilasciare [ e -lt e utilizzare (( per confronti aritmetici.

ps fornisce lo switch -C, che accetta il nome del processo da cercare.
grep -v gli inganni sono solo hack.

#!/usr/bin/env bash 

proc="scrape_data.php" 
limit=1 

numproc="$(ps hf -opid,cmd -C "$proc" | awk '$2 !~ /^[|\\]/ { ++n } END { print n }')" 

if ((numproc < limit)) 
then 
    # code when less than 'limit' processes run 
    printf "running processes: '%d' less than limit: '%d'.\n" "$numproc" "$limit" 
else 
    # code when more than 'limit' processes run 
    printf "running processes: '%d' more than limit: '%d'.\n" "$numproc" "$limit" 
fi 

Answer 3

Il conteggio delle linee non è necessario. Basta controllare il valore di ritorno di grep:

if ! ps -ef | grep -q '[s]crape_data.php' ; then 
    ... 
fi 

Il [s] trucco evita la grep -v grep.

Answer 4

Mentre la risposta più votata funziona effettivamente, ho una soluzione che ho usato per il mio raschietto che ha funzionato per me.

<?php 

/** 
* Go_Get.php 
* ----------------------------------------- 
* @author Thomas Kroll 
* @copyright Creative Commons share alike. 
* 
* @synopsis: 
*  This is the main script that calls the grabber.php 
*  script that actually handles the scraping of 
*  the RSI website for potential members 
* 
* @usage: php go_get.php 
**/ 

    ini_set('max_execution_time', 300); //300 seconds = 5 minutes 


    // script execution timing 
    $start = microtime(true); 

    // how many scrapers to run 
    $iter = 100; 

    /** 
    * workload.txt -- next record to start with 
    * workload-end.txt -- where to stop at/after 
    **/ 

    $s=(float)file_get_contents('./workload.txt'); 
    $e=(float)file_get_contents('./workload-end.txt'); 

    // if $s >= $e exit script otherwise continue 
    echo ($s>=$e)?exit("Work is done...exiting".PHP_EOL):("Work is not yet done...continuing".PHP_EOL); 

    echo ("Starting Grabbers: ".PHP_EOL); 

    $j=0; //gotta start somewhere LOL 
    while($j<$iter) 
    { 
     $j++; 
     echo ($j %20!= 0?$j." ":$j.PHP_EOL); 

     // start actual scraping script--output to null 
     // each 'grabber' goes and gets 36 iterations (0-9/a-z) 
     exec('bash -c "exec nohup setsid php grabber.php '.$s.' > /dev/null 2>&1 &"'); 

     // increment the workload counter by 36 characters    
     $s+=36; 
    } 
    echo PHP_EOL; 
    $end = microtime(true); 
    $total = $end - $start; 
    print "Script Execution Time: ".$total.PHP_EOL; 

    file_put_contents('./workload.txt',$s); 

    // don't exit script just yet... 
    echo "Waiting for processes to stop..."; 

    // get number of php scrapers running 
    exec ("pgrep 'php'",$pids); 
    echo "Current number of processes:".PHP_EOL; 

    // loop while num of pids is greater than 10 
    // if less than 10, go ahead and respawn self 
    // and then exit. 
    while(count($pids)>10) 
    { 
     sleep(2); 
     unset($pids); 
     $pids=array(); 
     exec("pgrep 'php'",$pids); 
     echo (count($pids) %15 !=0 ?count($pids)." ":count($pids).PHP_EOL); 
    } 

    //execute self before exiting 
    exec('bash -c "exec nohup setsid php go_get.php >/dev/null 2>&1 &"'); 
    exit(); 
?> 

Ora, mentre questo sembra un po 'eccessivo, ero già utilizzando PHP per raschiare i dati (come il vostro script php nel PO), quindi perché non usare il PHP come lo script di controllo?

In sostanza, si potrebbe chiamare lo script come questo:

php go_get.php

e poi basta aspettare che la prima iterazione dello script per terminare. Successivamente, viene eseguito in background, che è possibile vedere se si utilizza il conteggio dei pid dalla riga di comando o uno strumento simile come htop.

Non è glamour, ma funziona. :)