[Risolto] spegnere server inattivo

[headlightman]

.. sembra funzionare, anche con samba :-)
ho cambiato il percorso dello script perché volevo metterlo in una cartella dove ne avevo già altri (giusto per averli tutti assieme), ovviamente ho modificato nello script il percorso di cpu_usage.py, ho commentato tutte le righe che cominciano per "echo" e ho lanciato lo script con il comando "screen" descritto qualche post più in alto, fin qua tutto bene..!
PERO' dopo lo shutdown il file /tmp/shutdown.tmp sparisce, nonostante la riga "#rm ${FLAG}" sia commentata..!!
giusto così per provare, ho dato al file permessi di sola lettura, ma niente, ad ogni spegnimento del sistema il file si cancella..

[zdf_9]

Sull'esecuzione con il comando "screen" penso non sia necessario una volta commentati tutti gli echo... comunque l'importante è che funzioni.

Sulla cancellazione del file "/tmp/shutdownOK.tmp" non so' cosa dirti. Penso dipenda dalle varie distribuzioni il cancellare il contenuto della directory /tmp nel momento dello shutdown. Con archlinux i file rimangono per un certo perdiodo, con ubuntu mi sembrava rimanessero fin quando non venissero cancellati... ma probabilmente sbagliavo.
Per risolvere puoi modificare nello script il valore assegnato alla variabile, modificando a piacimento il percorso ed anche il nome, ad esempio FLAG="/root/shutdown_script_flag.tmp" al posto di FLAG="/tmp/shutdownOK.tmp"

Sono contento che sembra funzionare anche con samba.

[headlightman]

..... ho ascoltato il tuo suggerimento (cambiato posizione del file shutdownOK.tmp) e ho risolto :-) ho continuato a sperimentare e con mediatomb funziona in parte, il comando di spegnimento non parte solo perché il carico sul processore supera il limite, quando, ad esempio sento musica via DLNA.
poi volevo chiederti se c'è un modo per evitare che si spenga quando, ad esempio, sto lavorando direttamente sul server, senza dover cancellare il file.. come posso fermare lo script?
oppure, posso fargli controllare anche l'interfaccia grafica che uso ? (questa )

[zdf_9]

Ho riscritto lo script principale tenendo conto dei TODO che avevo scritto in un post precedente ed altre ottimizzazioni.

Codice: Seleziona tutto

#!/bin/sh

CPU_LIMIT=12
SLEEP_TIME=10s
SLEEP_TIME2=5m
SHUTDOWN_LIMIT=24
RM_FILE_FLAG_ENABLED=0
CPU_USAGE_SCRIPT="/aaa-script/cpu_usage.py"
FILE_FLAG_ENABLED="/home/USER/shutdown_script_enabled.tmp"
FILE_PS_TMP="/tmp/$0.tmp"
DATA="ssh::2 apt-get::0 bash:USER:0"

RM_CMD=/bin/rm
CAT_CMD=/bin/cat
AWK_CMD=/usr/bin/awk
ECHO_CMD=/bin/echo
GREP_CMD=/usr/bin/grep
SHUTDOWN_CMD=/sbin/shutdown

SHUTDOWN=0
TEST_FG=0
TEST_RUN=0

if [ ! -e ${CPU_USAGE_SCRIPT} ]; then
  echo "File $CPU_USAGE_SCRIPT not found."
  exit 2
fi

for arg in "$@" ; do
  if [ "${arg}" = "--test" ]; then
    TEST_FG=1
  fi
  if [ "${arg}" = "--run" ]; then
    RUN_FG=1
  fi
done

if [ $((TEST_FG + RUN_FG)) != 1 ]; then
  ${ECHO_CMD} $0 [--test] [--run]
  ${ECHO_CMD} "Usage:"
  ${ECHO_CMD} "--test    print variables"
  ${ECHO_CMD} "--run     execute shutdown"
  exit 1
fi

while true; do
  if [ -e ${FILE_FLAG_ENABLED} ]; then 
    SHUTDOWN=$(($SHUTDOWN + 1))

    ps aux > ${FILE_PS_TMP}
    for PROGRAM_AND_NUMBER in ${DATA}; do
      PROGRAM=`${ECHO_CMD} $PROGRAM_AND_NUMBER | ${AWK_CMD} -F : '{print $1}'`
      PROGRAM_PRM=`${ECHO_CMD} $PROGRAM_AND_NUMBER | ${AWK_CMD} -F : '{print $2}'`
      NUMBER_LIMIT=`${ECHO_CMD} $PROGRAM_AND_NUMBER | ${AWK_CMD} -F : '{print $3}'`
      if [ "${PROGRAM_PRM}" == "" ]; then
        PROCESSI=`${CAT_CMD} ${FILE_PS_TMP} | ${GREP_CMD} -c ${PROGRAM}`
      else
        PROCESSI=`${CAT_CMD} ${FILE_PS_TMP} | ${GREP_CMD} ${PROGRAM_PRM} | ${GREP_CMD} -c ${PROGRAM}`
      fi
      [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "${PROGRAM} (${PROCESSI} > ${NUMBER_LIMIT})"

      if [ ${PROCESSI} -gt ${NUMBER_LIMIT} ]; then
        SHUTDOWN=0
        break;
      fi
    done
    ${RM_CMD} ${FILE_PS_TMP}

    if [ ${SHUTDOWN} -ge 1 ]; then
      CPU_USAGE=`${CPU_USAGE_SCRIPT}`
      [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "CPU (${CPU_USAGE} >= ${CPU_LIMIT})"
      if [ ${CPU_USAGE} -ge ${CPU_LIMIT} ]; then
        SHUTDOWN=0
      fi
    fi

    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "shutdown ($SHUTDOWN >= $SHUTDOWN_LIMIT)"

    if [ ${SHUTDOWN} -ge ${SHUTDOWN_LIMIT} ]; then
      [ $((RM_FILE_FLAG_ENABLED)) = 1 ] && ${RM_CMD} ${FILE_FLAG_ENABLED}
      [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} ${SHUTDOWN_CMD} -h 0
      [ $((RUN_FG)) -eq 1 ] && ${SHUTDOWN_CMD} -h 0
    fi
  else
    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "Block shutdown - file '${FILE_FLAG_ENABLED}' not found"
    SHUTDOWN=0
  fi
  if [ $((SHUTDOWN)) -eq 0 ]; then
    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "*** SLEEP ${SLEEP_TIME2}"
    sleep ${SLEEP_TIME2}
  else
    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "*** SLEEP ${SLEEP_TIME}"
    sleep ${SLEEP_TIME}
  fi
  [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "-----"
done

exit 0

Ora lo script può essere lanciato in modalità "--test" (visualizza le variabili e non effettua lo shutdown) oppure "--run" (non visualizza nulla ed effettua lo shutdown).

Per ogni ciclo viene eseguito una sola volta il comando "ps".
Quando lo script si accorge che un programma blocca il shutdown, si mette in pausa per "SLEEP_TIME2=5m"
Il nome del file del flag è: FILE_FLAG_ENABLED="/home/USER/shutdown_script_enabled.tmp" (Modificarlo a piacimento) Modificare USER nella variabile
Esiste un flag RM_FILE_FLAG_ENABLED=0 (non cancella il file che abilita la parte interna dello script) impostarlo ad 1 per permettere la cancellazione del file stesso.
Ho modificato DATA="ssh::2 apt-get::0 bash:USER:0" per permettere il blocco anche nel caso esista un login dell'utente USER] (bash:USER:0). Per far questo ho dovuto aggiungere un ulteriore campo (e di conseguenda un ulteriore ":" ). Modificare USER nella variabile

@headlightman
Per aumentare il limite della cpu, modifica il valore "CPU_LIMIT=12" (esegui lo script come --test per decidere quale sia il valore più corretto)
Ora quando lavori direttamente su server come utente "USER", viene bloccato lo shutdown.
Non riesco a capire cosa intendi per controllare l'interfaccia grafica.

[headlightman]

rieccomi, tra ferie e altre cose non sono più riuscito ad andare avanti nelle prove :-(
ho aggiornato il tuo script, funziona perché fa lo shutdown, ma non tiene conto degli utenti connessi a samba e nemmeno del login dell'utente amministratore

Ho modificato DATA="ssh::2 apt-get::0 bash:USER:0" per permettere il blocco anche nel caso esista un login dell'utente USER] (bash:USER:0). Per far questo ho dovuto aggiungere un ulteriore campo (e di conseguenda un ulteriore ":" ). Modificare USER nella variabile

nel campo user devo mettere il nome dell'utente amministratore con la quale solitamente accedo?
ecco dopo aver lanciato lo script in modalità test:

Codice: Seleziona tutto

root@server:/home# sudo ./autoff.sh --test
./autoff.sh: 55: [: unexpected operator
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
ssh ( > 2)
./autoff.sh: 62: [: -gt: unexpected operator
./autoff.sh: 55: [: unexpected operator
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
apt-get ( > 0)
./autoff.sh: 62: [: -gt: unexpected operator
./autoff.sh: 55: [: XXXXXXXXXX: unexpected operator
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
bash ( > 1)
./autoff.sh: 62: [: -gt: unexpected operator
./autoff.sh: 55: [: unexpected operator
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
smbd ( > 2)
./autoff.sh: 62: [: -gt: unexpected operator
./autoff.sh: 55: [: unexpected operator
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
./autoff.sh: 1: ./autoff.sh: /usr/bin/grep: not found
nmbd ( > 1)
./autoff.sh: 62: [: -gt: unexpected operator
CPU (1 >= 12)
shutdown (1 >= 3)
*** SLEEP 10s

nel campo XXXXXX ci sarebbe il nome utente amministratore..!

[zdf_9]

Stò riscrivendo lo script con un altro modo per determinare l'utilizzo della CPU (c'è la possibilità di "escludere" dal conteggio alcuni programmi). Per il momento stò ancora combattendo con un comando "awk" che mi crea dei problemi. Quando ho un po' di tempo libero lo finisco e lo posto.

Riguardo allo script precedente, c'è un problema in una o più variabili *_CMD.
Essendo lo script eseguito come root, voglio essere sicuro che i programmi eseguiti siano quelli "di default" per evitare ogni possibile problema di sicurezza. Avendo installato un'altra distribuzione linux, le posizione dei programmi differiscono, e da qui il problema.
Puoi procedere in due modi:
1- ad ogni variabile *_CMD elimina il percorso (es: ECHO_CMD=echo)
2- controlla e nel caso modifica il percorso di ogni variabile *_CMD
Sicuramente le variabili che dovresti controllare sono: ECHO_CMD, AWK_CMD, GREP_CMD e CAT_CMD.
Ad esempio, per controllare la posizione corretta di ECHO_CMD, dai il comando:

Codice: Seleziona tutto

locate echo | grep bin

Ti restituirà una lista di programmi che contengono la stringa "echo"...

Se hai un po' di pazienza, attendi il nuovo script (prima di postarlo lo testerò con un ubuntu 12.04 installato sul computer di mio fratello).

Se qualdo l'utente pippo è loggato ed ha aperto un terminale non vuoi che il computer venga spento, modifica "bash:USER:0" in " bash:pippo:0"

[zdf_9]

Ho riscritto lo script, per testarlo eseguirlo con il parametro "--test", per renderlo esecutivo "--run".
Questo dopo aver controllato il numero di programmi in esecuzione e l'utilizzo della CPU per SHUTDOWN_LIMIT numero di volte consecutive, spegne il computer.

Prima di eseguire lo script, bisogna eseguire come utente "root" il comando "top".
Bisogna scrivere il file .toprc con l'Irix Mode abilitato (Irix Mode ON).
Premendo il tasto I (i maiuscolo) si abilita/disabilita l'Irix Mode.
Per salvare il file .toprc premere il tasto W.

Le variabili all'interno dello script hanno i seguenti significati:

• USER: l'utente con cui ci si connette la server (vedere DATA_PROGRAMS_CHECK e FILE_FLAG_ENABLED).
• CPU_LIMIT: il limite nell'utilizzo della CPU oltre il quale lo viene impostato a 0 il contatore di shutdown.
• SLEEP_TIME: il tempo di attesa tra un controllo e l'altro.
• SLEEP_TIME2: il tempo di attesa quando viene impostato a 0 il contatore di shutdown (solo --run).
• SLEEP_TIME3: il tempo di attesa prima di effettuare il primo controllo sui programmi in esecuzione e sull'utilizzo della CPU. (solo --run).
• SHUTDOWN_LIMIT: quando il contatore di shutdown raggiunge questo valore, il computer viene spento.
• VERBOSE_FG: 0/1 "Non viene"/"viene" visualizzata la lista dei processi con i relativi utilizzi della CPU (solo --test).
• DATA_PROGRAMS_CHECK: lista dei programmi che vengono controllati (imposto a 0 il contatore di shutdown se sono in esecuzione più processi di quelli voluti). Il formato di ogni dato è: "/path/programma:utente che ha lanciato l'esecuzione:numero di programmi eseguibili"
  Non indicando l'utente, vengono presi in considerazione tutti gli utenti che hanno eseguito il programma.
• DATA_PROGRAMS_EXCLUDE_TIMER: lista dei programmi che vengono esclusi dal calcolo dell'utilizzo della CPU. Il formato di ogni dato è: "/path/programma"
• FILE_FLAG_ENABLED: se esiste il file, viene abilitata l'esecuzione dello script. (serve per abilitare/disabilitare l'esecuzione dello script).
• RM_FILE_FLAG_ENABLED: 0/1 "Non cancella/cancella" il file FILE_FLAG_ENABLED appena prima di spegnere il computer. (lo script è eseguito una sola volta).
• FILE_PS_TMP: il file temporaneo del comando ps.
• FILE_TOP_TMP: il file temporaneo del comando top.

Note aggiuntive:

• DATA_PROGRAMS_CHECK contiene i valori "/bin/sh:root:1 /bin/bash:root:0 /bin/sh:${USER}:0 /bin/bash:${USER}:0".
  Per root permette l'esecuzione di un solo processo "/bin/sh" (lo script di shutdown è eseguito da questo ambiente) e nessun "bash".
  Per l'utente specificato dalla variabile $USER, non sono permessi processi "sh" o "bash".
  Quando si esegue lo script in modalità "--test" conviene usare un altro utente (non $USER o "root") oppure modificare aggiungendo 90 al valore numerico di queste variabili. (/bin/sh:root:91 /bin/bash:root:90 /bin/sh:${USER}:90 /bin/bash:${USER}:90)
• CPU_NUMBER è il numero delle CPU presenti nel computer (la variabile viene ricavata direttamente dallo script).

Il nuovo script:

Codice: Seleziona tutto

#!/bin/sh
# in /etc/rc.local add before "exit 0"
# /directory/scriptname --run &

USER=zdf_9
CPU_LIMIT=5.2
SLEEP_TIME=10s
SLEEP_TIME2=5m
SLEEP_TIME3=2m
SHUTDOWN_LIMIT=12
VERBOSE_FG=1
DATA_PROGRAMS_CHECK="/usr/bin/ssh::0 /usr/bin/apt-get::0 /bin/sh:root:1 /bin/bash:root:0 /bin/sh:${USER}:0 /bin/bash:${USER}:0"
DATA_PROGRAMS_EXCLUDE_TIMER="/usr/bin/X /usr/bin/Xorg /usr/sbin/unity-greeter /usr/lib/gnome-terminal/gnome-terminal-server /usr/bin/top /usr/bin/vlc /usr/bin/pulseaudio"
FILE_FLAG_ENABLED="/home/${USER}/shutdown_script_enabled.tmp"
RM_FILE_FLAG_ENABLED=0
BASENAME_CMD=/usr/bin/basename
FILE_PS_TMP="/tmp/`$BASENAME_CMD $0`_ps.tmp"
FILE_TOP_TMP="/tmp/`$BASENAME_CMD $0`_top.tmp"
export COLUMNS=200

PS_CMD=/bin/ps
RM_CMD=/bin/rm
BC_CMD=/usr/bin/bc
CAT_CMD=/bin/cat
AWK_CMD=/usr/bin/awk
SED_CMD=/bin/sed
TOP_CMD=/usr/bin/top
ECHO_CMD=/bin/echo
GREP_CMD=/bin/grep
SHUTDOWN_CMD=/sbin/shutdown

SHUTDOWN=0
TEST_FG=0
TEST_RUN=0

if [ ! -e ${CPU_USAGE_SCRIPT} ]; then
  echo "File $CPU_USAGE_SCRIPT not found."
  exit 2
fi

for arg in "$@" ; do
  if [ "${arg}" = "--test" ]; then
    TEST_FG=1
  fi
  if [ "${arg}" = "--run" ]; then
    RUN_FG=1
  fi
done

if [ $((TEST_FG + RUN_FG)) != 1 ]; then
  ${ECHO_CMD} $0 [--test] [--run]
  ${ECHO_CMD} "Usage:"
  ${ECHO_CMD} "--test    print variables"
  ${ECHO_CMD} "--run     execute shutdown"
  exit 1
fi

CPU_NUMBER=`$AWK_CMD '/^processor/ { N++} END { print N }' /proc/cpuinfo`
[ $((RUN_FG)) -eq 1 ] && ${SLEEP_CMD} ${SLEEP_TIME3}
while true; do
  if [ -e ${FILE_FLAG_ENABLED} ]; then
    SHUTDOWN=$(($SHUTDOWN + 1))
    $PS_CMD -eo user,pcpu,command > ${FILE_PS_TMP}
    for PROGRAM_AND_NUMBER in ${DATA_PROGRAMS_CHECK}; do
      PROGRAM=`${ECHO_CMD} $PROGRAM_AND_NUMBER | ${AWK_CMD} -F : '{print $1}'`
      PROGRAM_PRM=`${ECHO_CMD} $PROGRAM_AND_NUMBER | ${AWK_CMD} -F : '{print $2}'`
      NUMBER_LIMIT=`${ECHO_CMD} $PROGRAM_AND_NUMBER | ${AWK_CMD} -F : '{print $3}'`
      PROGRAM_BASE=`${BASENAME_CMD} ${PROGRAM}`
      PROCESSI=`$AWK_CMD -v progname1="${PROGRAM}" -v progname2="${PROGRAM_BASE}" -v progprm="${PROGRAM_PRM}" \
'BEGIN {somma=0;} {if (progname1 == $3 || progname2 == $3 )
 { if (progprm == "" || progprm == $1) {somma++;}}}; END {print somma;}' ${FILE_PS_TMP}`
      [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "${PROGRAM} (${PROCESSI} > ${NUMBER_LIMIT})"
      if [ ${PROCESSI} -gt ${NUMBER_LIMIT} ]; then
        SHUTDOWN=0
        break;
      fi
    done
    ${RM_CMD} ${FILE_PS_TMP}

    if [ ${SHUTDOWN} -ge 1 ]; then
      [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD}

      TIME_USED_PROGRAM=0
      $TOP_CMD -S -c -b -n 2 | $SED_CMD 's/\,/\./g' | $SED_CMD 's/\^[ ]+//g' > ${FILE_TOP_TMP}

      $SED_CMD -i '1,/load average/d' ${FILE_TOP_TMP}
      TIME_USED_TOTAL=`$AWK_CMD -v prog=${PROGRAM} 'BEGIN {somma=0;} {if (NR >6) { valore=$9; somma+=valore; }}; END {printf ("%2.1f",somma);}' ${FILE_TOP_TMP}`
      if [ $((TEST_FG)) -eq 1 ]; then
        ${ECHO_CMD} "CPU: ${TIME_USED_TOTAL}"
        ${ECHO_CMD}
      fi
      for PROGRAM in ${DATA_PROGRAMS_EXCLUDE_TIMER}; do
        TIME_USED=`$AWK_CMD -v prog=${PROGRAM} 'BEGIN {somma=0;} {if (prog == $12 && length(prog) == length($12)) { valore=$9; somma+=valore;}}; END {printf ("%2.1f\n",somma);}' ${FILE_TOP_TMP}`
        TIME_USED_PROGRAM=`$ECHO_CMD "${TIME_USED_PROGRAM} + ${TIME_USED}" | $BC_CMD | awk '{printf "%2.1f\n", $0}'`
        [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "CPU: ${PROGRAM} = ${TIME_USED} - Total = ${TIME_USED_PROGRAM}"
      done
      CPU_USAGE_OK=`$ECHO_CMD "scale=2;((${TIME_USED_TOTAL}-${TIME_USED_PROGRAM})/${CPU_NUMBER})" | $BC_CMD | awk '{printf "%2.1f\n", $0}'`
      if [ $((TEST_FG)) -eq 1 ]; then
        ${ECHO_CMD}
        ${ECHO_CMD} "CPU: ((${TIME_USED_TOTAL}-${TIME_USED_PROGRAM})/${CPU_NUMBER}) ${CPU_USAGE_OK} >= ${CPU_LIMIT}"
      fi
      CPU_NOPASS=`$ECHO_CMD "${CPU_USAGE_OK} >= ${CPU_LIMIT}" | $BC_CMD`
      if [ $((CPU_NOPASS)) -eq 1 ]; then
        if [ $((TEST_FG)) -eq 1 ]; then
          if [ $((VERBOSE_FG)) -eq 1 ]; then
            ${ECHO_CMD}
            $AWK_CMD -v prog=${PROGRAM} '{if (NR>6) { valore=$9; if (valore!=0) {print $0;}}};' ${FILE_TOP_TMP}
          fi
        fi
        SHUTDOWN=0
      fi
      ${RM_CMD} ${FILE_TOP_TMP}
    fi

    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD}

    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "shutdown ($SHUTDOWN >= $SHUTDOWN_LIMIT)"
    if [ ${SHUTDOWN} -ge ${SHUTDOWN_LIMIT} ]; then
      [ $((RM_FILE_FLAG_ENABLED)) = 1 ] && ${RM_CMD} ${FILE_FLAG_ENABLED}
      [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} ${SHUTDOWN_CMD} -h 0
      [ $((RUN_FG)) -eq 1 ] && ${SHUTDOWN_CMD} -h 0
    fi
  else
    [ $((TEST_FG)) -eq 1 ] && ${ECHO_CMD} "Block shutdown - file '${FILE_FLAG_ENABLED}' not found"
    SHUTDOWN=0
  fi

  SLEEP_TIME_OK=${SLEEP_TIME}
  if [ $((SHUTDOWN)) -eq 0 ]; then
    SLEEP_TIME_OK=${SLEEP_TIME2}
  fi

  if [ $((RUN_FG)) -eq 1 ]; then 
    sleep ${SLEEP_TIME_OK}
  else
    ${ECHO_CMD}
    ${ECHO_CMD} "*** SLEEP ${SLEEP_TIME_OK}"
    sleep ${SLEEP_TIME}
    ${ECHO_CMD} "-----"
  fi
done

exit 0