bash

Monitorare la dimensione di un filesystem

In Linux per conoscere quanto spazio resta ai filesystems si usa il comando df. Un esempio di output del comando è:

root@mazinga:~# df -lh
Filesystem                 Size  Used Avail Use% Mounted on
rootfs                      20G  3.3G   16G  18% /
udev                        10M     0   10M   0% /dev
tmpfs                       50M  144K   50M   1% /run
/dev/disk/by-label/DOROOT   20G  3.3G   16G  18% /
tmpfs                      5.0M     0  5.0M   0% /run/lock
tmpfs                      100M     0  100M   0% /run/shm
root@mazinga:~#

Se si volesse quindi monitorare lo stato di un particolare mount point si può usare uno script come il seguente:

#!/bin/bash
 
# lo script confronta la percenuale di spazio utilizzata nel filesystem / con $SOGLIA
# se la percentuale supera $SOGLIA invia una mail a $RECIPIENTS
 
# imposto una soglia del 90%
SOGLIA=90
 
# imposto i destinatari della mail
RECIPIENTS="pippo@example.com"
 
now=`date +%y%m%d-%H%M%S`
 
perc_root=`df -Ph -x tmpfs -x rootfs | grep "/$" |  tr -s ' ' '\t' | cut -f5 -s | cut -d '%' -f1`
 
found=false
msg="Analizzatore dell'uso dello spazio su disco (SOGLIA impostata a "${SOGLIA}"):\n\n"
 
if [[ "${perc_root}" -ge "${SOGLIA}" ]] ; then
    found=true
    msg+="Il file system '/' sta utilizzando il "${perc_var}"% del suo spazio disponibile\n"
fi
 
if "${found}" ; then
    echo -e ${msg} | mail -s "Controllo su spazio disco del ${now}" $RECIPIENTS
fi

La parte interessante è il comando che ricava la percentuale da df:

  • la prima parte (df -Ph -x tmpfs -x rootfs) invoca il comando df usando il flag -x che permette di escludere un filesystem e il flag -P che imposta l'output in formato POSIX (i dati dei filesystem sono tutti nella stessa riga);
  • la seconda parte ( grep "/$" ) serve a puntare il filesystem desiderato;
  • la terza parte serve a puntare la colonna desiderata e ripulisce il campo dal carattere % in modo da poterlo usare in un test.

Lo script se messo in cron inizierà ad inviarvi una mail non appena lo spazio utilizzato nel filesystem root arriverà a superare il 90%.

Blog: 

Programmazione: 

Un mediacenter con Serviio



Serviio è una applicazione che fornisce tutte le funzionalità tipiche di un media center. Di seguito vedremo come installarla su un server debian headless.

Per prima cosa dovremo installare Java: l'ultima versione attualmente disponibile di serviio richiede che sia installato java 8. Per l'installazione di java rimando ad un mio vecchio post.

Unaa volta installato java dovremo installare ffmpeg. La versione di ffmpeg che si trova nei repository debian è piuttosto vecchia quindi consiglio di prendere quella compilata staticamente per la propia architettura (32/64 bit) direttamente da qui.

Arrivati a questo punto possiamo scaricare Serviio da questo link.

L'installazione prevede di scompattare l'archivio scaricato in una directory a piacere. Nel caso si esegua un upgrade è sufficiente ricordarsi di portare la directory library dalla precedente versione, in questo modo non si perdono i riferimenti alle librerie che si sono condivise.

Se si vuole far partire serviio all'avvio del computer si può creare uno script di init. A questo link ne ho trovato uno che riporto qui per completezza: in

/etc/default

si deve creare il file con nome serviio con il seguente contenuto:

#########################################################
#- Daemon Script Configuration for Serviio Media Server
#- By Ian Laird
#- /etc/default/serviio
#########################################################
 
NAME="Serviio Media Server"
DAEMON="/opt/serviio-current/bin/serviio.sh"    ## Update this to point at serviio_root/bin/serviio.sh
SERVICE_ACCOUNT="gtrev"                       ## change to an appropriate username, DON'T RUN UNDER ROOT!

mentre in:

/etc/default

si deve inserire:

#!/bin/bash
#
#########################################################
#- Daemon script for Serviio media server
#- By Ian Laird; converted for Debian by Jacob Lundberg
#- /etc/init.d/serviio
#########################################################
#
### BEGIN INIT INFO
# Provides:          serviio
# Required-Start:    $local_fs $remote_fs $network $syslog
# Required-Stop:     $local_fs $remote_fs $network $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# X-Interactive:     true
# Short-Description: Start/stop serviio media server
# Description:       The Serviio media server makes your media available to
#                    all kinds of networked devices.
### END INIT INFO
 
 
. /lib/lsb/init-functions
 
if [ -f /etc/default/rcS ]; then
        . /etc/default/rcS
fi
 
 
DAEMON_STOP=" -stop"
NAME="$(basename $0)"
PIDFILE="/var/run/serviiod.pid"
TIMEOUT=10
 
if [ -f /etc/default/serviio ]; then
        . /etc/default/serviio
fi
 
[ -x "$DAEMON" ] || exit 0
 
 
running() {
        if [ "x$1" == "x" ]; then
                echo 0
                return 1
        fi
 
        PS=$(ps h -p $(echo $1 | sed -r 's/[\t \n]+/ -p /') | wc -l)
        echo $PS
 
        if [ $PS -gt 0 ]; then
                return 0
        else
                return 1
        fi
}
 
 
start() {
        log_daemon_msg "Starting Serviio media server daemon" "$NAME"
        start-stop-daemon --start -q -b -p "$PIDFILE" -m -c "${SERVICE_ACCOUNT}" -x "${DAEMON}"
        log_end_msg $?
}
 
stop() {
        log_daemon_msg "Stopping Serviio media server daemon" "$NAME"
        if [ -r "$PIDFILE" ]; then
                PIDS=$(pstree -p $(<"$PIDFILE") | awk -F'[\(\)]' '/^[A-Za-z0-9]/ { print $2" "$4; }')
                if running "$PIDS" > /dev/null; then
                        "${DAEMON}" "${DAEMON_STOP}"
                        for PID in $PIDS; do
                                if running $PID > /dev/null; then
                                        kill -TERM $PID
                                fi
                        done
                fi
                COUNTDOWN=$TIMEOUT
                while let COUNTDOWN--; do
                        if ! running "$PIDS" > /dev/null; then
                                break
                        fi
                        if [ $COUNTDOWN -eq 0 ]; then
                                for PID in $PIDS; do
                                        if running $PID > /dev/null; then
                                                kill -KILL $PID
                                        fi
                                done
                        else
                                echo -n .
                                sleep 1
                        fi
                done
        fi
 
        if running "$PIDS" > /dev/null; then
                log_end_msg 1
        else
                rm -f "$PIDFILE"
                log_end_msg $?
 
        fi
}
 
status() {
        echo -n "$NAME should be"
        if [ -r "$PIDFILE" ]; then
                echo -n " up with primary PID $(<"$PIDFILE")"
                PIDS=$(pstree -p $(<"$PIDFILE") | awk -F'[\(\)]' '/^[A-Za-z0-9]/ { print $2" "$4; }')
                RUNNING=$(running "$PIDS")
                if [[ $RUNNING && $RUNNING -gt 0 ]]; then
                        echo -n " and $RUNNING processes are running."
                else
                        echo -n " but it is not running."
                fi
        else
                echo -n " stopped."
        fi
        echo
}
 
 
case "${1:-}" in
        start)
                start
        ;;
        stop)
                stop
        ;;
        restart)
                stop
                start
        ;;
        status)
                status
        ;;
        *)
                log_success_msg "Usage: /etc/init.d/$NAME {start|stop|restart|status}"
                exit 1
        ;;
esac
 
exit 0

Dopo aver creato i file con il contenuto esposto si deve:

  # chmod 755 /etc/init.d/serviio
  # update-rc.d serviio defaults

In questo modo ad ogni riavvio della macchina il servizio ripartirà in automatico.

Per controllare serviio possiamo usare il suo client facendo attenzione che il client richiede che sia attivo il server X. Ovviamente nel caso in cui, come me, abbiate installato serviio in un server headless è sempre possibile connettersi al servizio dall'esterno. Bisognerà disporre di un computer che abbia l'ambiente grafico attivo: si dovrà scompattare l'archivio di serviio e modificare il file serviio-console.sh indicando l'IP del server che abbiamo prima configurato:

--- /tmp/serviio-console.sh     2015-03-26 23:14:55.916278243 +0100
+++ serviio-console.sh  2014-04-03 20:01:28.731745698 +0200
@@ -54,7 +54,7 @@
 SERVIIO_CONSOLE_CLASS_PATH="$SERVIIO_CONSOLE_HOME/lib/*:$SERVIIO_CONSOLE_HOME/config"
 
 # Setup Serviio specific properties
-JAVA_OPTS="-Dserviio.home=$SERVIIO_CONSOLE_HOME -Djava.net.preferIPv4Stack=true"
+JAVA_OPTS="-Dserviio.remoteHost=10.0.0.12 -Dserviio.home=$SERVIIO_CONSOLE_HOME -Djava.net.preferIPv4Stack=true"
 
 # For Cygwin, switch paths to Windows format before running java
 if $cygwin; then

e sarà sufficiente attivare la console:

gtrev@debian-laptop:~$ cd serviio/serviio-1.4.1.2/bin/
gtrev@debian-laptop:~/serviio/serviio-1.4.1.2/bin$ ./serviio-console.sh 

Blog: 

Programmazione: 

Trucchetto SSH (e nc)

Mi capita di dover connettermi a delle macchine all'interno di una lan che non hanno alcuna porta esposta verso internet. La lan ha una sola macchina esposta su internet che ha il servizio SSH attivo. Solitamente quindi si accede prima alla macchina esposta, che chiameremo A, e da questa alle successive (che chiameremo B,C,...):

 $ ssh A
 A$  ssh B

C'è però un piccolo trucco di ssh che permette di eseguire direttamente un ssh B senza apparentemente passare prima per il ssh A e prevede l'uso combinato di ssh e netcat.

Andiamo infatti a definire nel file .ssh/config la seguente entry:

1
2
3
4
5
6
7
8
9
Host A
    Hostname    1.2.3.4
    User        pippo
    IdentityFile               ~/.ssh/id_rsa
 
Host B
     User                       pippo
     HostName                   192.168.10.20
     ProxyCommand               ssh -q A nc %h 22

Alla prima riga andiamo a definire i parametri per accedere al server della lan esposto su internet, mentre alla riga 6 indichiamo che quando viene richiesta una connessione all'host B prima viene eseguita una connessione ad A che agisce da proxy verso B.

Con questo piccolo trucchetto possiamo dimenticarci che dobbiamo passare prima per A per andare a B e ci permette di fare direttamente un ssh B.

Blog: 

Programmazione: 

Subscribe to RSS - bash