====== Scriptschnipsel ======
Hier sind div. Schnipsel aus irgendwelchen Scripten zusammengestellt, die vielleicht einen Denkanstoß beim
scripten bringen.

===== Grundlagen =====
  * Zahlen-Arrays \\ <code>{1..5}</code>
  * Variablen werden nicht in Abschnitten, welche mit singel-Quotes (<key>'</key>) definiert sind, übergeben/umgesetzt. Lösung ist eine aufteilen der Abschnitte \\ **Funktioniert nicht** \\ <code>'BEFEHLSCODE "PARAMETER" ${VARIABLE} "PARAMETER" BEFEHLSCODE "PARAMETER" '</code> **Funktoniert** \\ <code>'BEFEHLSCODE "PARAMETER"' ${VARIABLE} '"PARAMETER" BEFEHLSCODE "PARAMETER" '</code>

===== IF-Bedinungen =====
^ Bedingung ^ Beschreibung ^
| -r Dateiname | Die Datei Dateiname existiert und ist lesbar |
| -w Dateiname | Die Datei Dateiname existiert und ist beschreibbar |
| -x Dateiname | Die Datei Dateiname existiert und ist ausführbar |
| -d Dateiname | Die Datei Dateiname existiert und ist ein Verzeichnis |
| -s Dateiname | Die Datei Dateiname existiert und ist nicht leer |
| -b Dateiname | Die Datei Dateiname existiert und ist ein blockorientiertes Gerät |
| -c Dateiname | Die Datei Dateiname existiert und ist ein zeichenorientiertes Gerät |
| -g Dateiname | Die Datei Dateiname existiert und das SGID-Bit ist gesetzt |
| -k Dateiname | Die Datei Dateiname existiert und das Sticky-Bit ist gesetzt |
| -u Dateiname | Die Datei Dateiname existiert und das SUID-Bit ist gesetzt |
| -p Dateiname | Die Datei Dateiname existiert und ist ein Named Pipe |
| -e Dateiname | Die Datei Dateiname existiert |
| -f Dateiname | Die Datei Dateiname existiert und ist eine reguläre Datei |
| -L Dateiname | Die Datei Dateiname existiert und ist ein symbolischer Link |
| -S Dateiname | Die Datei Dateiname existiert und ist ein Socket |
| -O Dateiname | Die Datei Dateiname existiert und ist Eigentum des Anwenders, unter dessen UID das test-Programm gerade läuft |
| -G Dateiname | Die Datei Dateiname existiert und gehört zu der Gruppe, zu der der User gehört, unter dessen UID das test-Programm gerade läuft |
| Datei1 -nt Datei2 | Datei1 ist neuer als Datei2 (newer than) |
| Datei1 -ot Datei2 | Datei1 ist älter als Datei2 (older than) |
| Datei1 -ef Datei2 | Datei1 und Datei2 benutzen die gleiche I-Node (equal file) |
| -z Zeichenkette | Wahr wenn Zeichenkette eine Länge von Null hat. |
| -n Zeichenkette | Wahr wenn Zeichenkette eine Länge von größer als Null hat. |
| Zeichenkette1 = Zeichenkette2 | Wahr wenn Zeichenkette1 gleich Zeichenkette2 |
| Zeichenkette1 != Zeichenkette2 | Wahr wenn Zeichenkette1 ungleich Zeichenkette2 |
| Wert1 -eq Wert2 | Wahr, wenn Wert1 gleich Wert2 (equal) |
| Wert1 -ne Wert2 | Wahr, wenn Wert1 ungleich Wert2 (not equal) |
| Wert1 -gt Wert2 | Wahr, wenn Wert1 größer Wert2 (greater than) |
| Wert1 -ge Wert2 | Wahr, wenn Wert1 größer oder gleich Wert2 (greater or equal) |
| Wert1 -lt Wert2 | Wahr, wenn Wert1 kleiner Wert2 (less than) |
| Wert1 -le Wert2 | Wahr, wenn Wert1 kleiner oder gleich Wert2 (less or equal) |
| !Ausdruck | Logische Verneinung von Ausdruck |
| Ausdruck -a Ausdruck | Logisches UND. Wahr, wenn beide Ausdrücke wahr sind |
| Ausdruck -o Ausdruck | Logisches ODER. Wahr wenn mindestens einer der beiden Ausdrücke wahr ist |
Quelle: [[http://www.linux-praxis.de/linux1/shell2_5.html]]

==== IF und Groß-/Kleinschreibung ====
<code bash>if [ <BEDINGUNG> == "y" -o <BEDINGUNG> == "Y" ]; then
  <BEFEHL>
fi</code>

==== IF mit default Wert ====
Hier bei fragt das Programm "Wollen Sie etwas tun?". Man kann nun entweder "y" oder "Y" oder garnichts eingeben damit der Befehl un der If Anweisung ausgeführt wird.
Wenn man etwas anderen angibt, dann wird abgebrochen.
<code bash>read -p "Wollen Sie etwas tun? [y|Y] ANTWORT
ANTWORT=${ANTWORT:=Y}
if [ $ANTWORT == "y" -o $ANTWORT == "Y" ]; then
  <BEFEHL>
else
  exit
fi</code>

==== Ordner prüfen ====
Erstellen eines Ordners wenn er nicht existiert.
<code bash>if [ ! -d "<ORDNER_NAME>" ]; then
  <BEFEHL>
else
  exit
fi</code>

==== Befehl existiert ====
Prüfen ob ein Befehl existiert.
<code bash>if [ -x $(command -v <BEFEHL>)  ]; then
  echo "existiert nicht"
fi</code>
===== Parameter =====
Das '':'' Zeichen hinter den Parametern (H,C,T) sagt aus, dass zu dem Parameter noch Argumente angegeben werden müssen.
<code bash>while getopts "H:C:T: -l text" opt; do
        case "$opt" in
        H )
                HOST="$OPTARG"
                ;;
        C )
                COMMUNITY="$OPTARG"
                ;;
        T )
                TEST="$OPTARG"
                ;;
        text )
                TEXT="$OPTARG" # langer Parameter (--text)
                echo $TEXT
                ;;
        * )
                usage
                ;;
        esac
done</code>

===== Ordnerstruktur kopieren =====
<code bash>#!/bin/bash

PATH_OLD=""
PATH_NEW=""

for i in `ls ${PATH_OLD}`; do
mkdir ${PATH_NEW}/$i
mv ${PATH_OLD}/$i ${PATH_NEW}/$i
done</code>

===== Nur bestimmte Dateien inkl. Ordnerstruktur kopieren =====
<code bash>find /Pfad/zu/Dateien -name "*.jpg" -exec cp --parents {} /Pfad/zu/Ziel \;</code>
WICHTIG: Wenn beim zu suchenden Begriff Asterisks oder andere Joker verwendet werden, immer die Suchbegriffe mit Anführungszeichen ("), wie dargestellt, oder mit direkt vorangehendem Backslash (\) versehen.

Wenn man bei dieser Methode nicht die Dateien kopieren sondern dafür nur SymLinks erstellen möchte, dann 
muss man zum Copy-Befehl noch folgendes hinzufügen ''-s''

===== Datensicherung =====
siehe [[linux:backupscript]]

===== Verzeichnisse vergleichen =====
<code bash>diff -rqy <DIR1> <DIR2></code>

^ Parameter ^ Beschreibung ^
| ''r'' | recursiv |
| ''q'' | kurze ausgabe; nur unterschiedliche Dateien anzeigen |
| ''y'' | tabelarische Ausgabe |
===== Mit "ls" nur Ordner anzeigen =====
<code bash>ls -d <PFAD> | sed 's!/$!!'</code>

===== Mit "ls" nur Dateien anzeigen =====
<code>ls -l <PFAD> | awk '{print $9}'</code>
oder eine einzelne Datei
<code>ls -l <PFAD> | awk '{print $9}'|grep <DATEINAME></code>

===== Prüfsumme großer Verzeichnisse =====
<code bash>#!/bin/bash

CMDHOSTNAME=`which hostname`
HOSTNAME=`${CMDHOSTNAME} -s`
CMDLS=`which ls`
CMDCFV=`which cfv`
CMDSORT=`which sort`
CMDSED=`which sed`
CMDCAT=`which cat`
CMDMD5SUM=`which md5sum`

CHECKDIR=<PFAD_ZUM_ZUPRÜFENDEM_VERZEICHNIS>
WORKDIR=<PFAD_ZUM_VERZEICHNIS_DIESES_SCRIPTES>
DIRLIST=${WORKDIR}/dirlist-${HOSTNAME}
MD5DIR=${WORKDIR}/md5-${HOSTNAME}
LOG=${WORKDIR}/md5-${HOSTNAME}.log
CHECKFILE=${WORKDIR}/gesamt-${HOSTNAME}.md5

if [ ! -d ${MD5DIR} ]; then
        mkdir ${MD5DIR}
fi

${CMDLS} -d ${CHECKDIR}/*/ | ${CMDSORT} | ${CMDSED} 's!/$!!' | ${CMDSED} 's!/.*/!!' > ${DIRLIST}

for elem in `${CMDCAT} ${DIRLIST}`; do
        if [ ! -f ${MD5DIR}/${elem}.md5 ]; then
                ${CMDCFV} -rr -C -t md5 -f ${MD5DIR}/${elem}.md5 ${CHECKDIR}/${elem} #> /dev/null
        fi
done

${CMDMD5SUM} ${MD5DIR}/*.md5 > ${CHECKFILE}</code>

===== CD-Copy mit MD5-Vergleich =====
<code bash>#!/bin/bash

# Variablen
DEST=<ZIELPFAD>
MOUNTTIMEOUT=30

#eject # Laufwerk oeffnen falls nicht bereits geoeffnet

# Programmschleife startet
while true; do

  # Medien einlegen
  echo Medium einlegen und DVD Nr. eingeben

  while true; do
    read -p "DVD Nummer:" MEDIENNR  # Abfrage: Mediennummer

    if [[ $MEDIENNR =~ ^exit|quit$ ]] ; then
      exit 0
    fi

    if ! [[ $MEDIENNR =~ ^[0-9]+$ ]] ; then
      tput setaf 1 # http://en.wikipedia.org/wiki/Tput
      echo Nur Zahlen erlaubt
      tput sgr0
      continue
    else
      break
    fi
  done

  date "+%d.%m.%y %H:%M:%S"

  WORKDIR=$DEST/$MEDIENNR

  if [ -d "$WORKDIR" ]; then
    tput setaf 1
    echo Directory $WORKDIR exisitert bereits
    tput sgr0
    read -p "Enter to continue"
    continue
  fi

  eject -t
  echo mounte Medium ... Einen Augenblick bitte

  # Medium mounten mit Fehlerkontrolle
  COUNTER=1
  for i in `seq 1 $MOUNTTIMEOUT`; do
    if  mount|grep -q sr0; then
      break
    else
      let COUNTER=COUNTER+1
      echo -n .
      sleep 1
    fi
  done
  
   echo # Zeilenumbruch nach Progressbar

  if [[ COUNTER -gt $MOUNTTIMEOUT ]]; then
    tput setaf 1
    echo Medium ist nicht mountbar!
    tput sgr0
    tput bel
    read -p "Enter to continue"
    eject
    continue
  fi

  # Medium gefunden
  MEDIUMNAME=$(ls /media)
  MEDIUMMOUNTPATH=$(mount | grep sr0 | grep -Eo "/media(.*) type" | sed 's/ type//')

  echo Workdir: $WORKDIR
  echo Medienname: $MEDIUMNAME
  echo Mountpath: $MEDIUMMOUNTPATH

  mkdir -p "$WORKDIR/$MEDIUMNAME"

  echo md5sum des medium nach $WORKDIR/md5_medium.md5
  find "$MEDIUMMOUNTPATH/" -type f -print0 | while read -d $'\0' -r file ; do
    md5sum "$file" | grep -o '^[0-9a-f]*' >> "$WORKDIR/md5_medium.tmp"
  done
  cat "$WORKDIR/md5_medium.tmp" | sort > "$WORKDIR/md5_medium.md5"

  # Daten von Medium in Workdir kopieren
  echo "Daten von Medium nach $WORKDIR/$MEDIUMNAME kopieren"
  #touch "$WORKDIR/$MEDIUMNAME"/foo
  cp -ru "$MEDIUMMOUNTPATH/"* "$WORKDIR/$MEDIUMNAME"

  echo md5sum der kopierten Daten nach $WORKDIR/md5_copy.md5
  find "$WORKDIR/$MEDIUMNAME/" -type f -print0 | while read -d $'\0' -r file ; do
    md5sum "$file" | grep -o '^[0-9a-f]*' >> "$WORKDIR/md5_copy.tmp"
  done
  cat "$WORKDIR/md5_copy.tmp" | sort > "$WORKDIR/md5_copy.md5"

  echo Vergleich von md5_medium.md5 und md5_copy.md5
  DIFFRESULT=$(diff "$WORKDIR/md5_medium.md5" "$WORKDIR/md5_copy.md5")

  echo # leerzeile ueber Ergebnis

  ENDTIME=$(date "+%d.%m.%y %H:%M:%S")
  if [ "$DIFFRESULT" != "" ]; then
    # ungleich
    tput setaf 1 # color red
    echo $ENDTIME MD5 Hash unterschiedlich
  else
    # gleich
    tput setaf 2 # color green
    echo $ENDTIME MD5 Hash identisch
    rm "$WORKDIR/md5_medium.tmp"
    rm "$WORKDIR/md5_copy.tmp"
     fi
  tput sgr0
  echo # leerzeile unter Ergebnis

  tput bel

  eject # Medium auswerfen

done # Schleife ende</code>
===== find =====

==== Dateien oder Ordner mit find im Zeitraum löschen ====
Dateien suchen und in einem bestimmten Zeitraum löschen.
  * Zeitraum
    * Datumsformat: jjjj-mm-dd <code bash>touch --date "<JÜNGSTES_DATUM>" end
touch --date "<ÄLTESTES_DATUM>" start</code>
    * Dateien suchen und löschen <code bash>find <VERZEICHNIS> -type f -newer <PFAD>/start -not -newer <PFAD>/end -exec rm -rf {} \;</code>
  * löschen wenn n Tage älter <code bash>find <PFAD>/* -mtime +n -exec rm {} \;</code>
Bedeutung Parameter (Quelle: [[https://wiki.ubuntuusers.de/]])
^ -mtime n | sucht nach Dateien, deren Inhalt vor n bis n+1 Tagen geändert (m=modified) wurde. |
^ -mtime +n | sucht nach Dateien, deren Inhalt älter als n+1 Tage ist. |
^ -mtime -n | sucht nach Dateien, deren Inhalt jünger als n Tage ist. |
^ -ctime n | sucht nach Dateien, deren Name oder Status (Modus, Besitzer oder Gruppe) vor n bis n+1 Tagen geändert (c=changed) wurde. |
^ -atime n | sucht nach Dateien, auf die zuletzt vor n bis n+1 Tagen zugegriffen (a=accessed) wurde. (Hinweis: Die Aussagekraft der Datei-Zugriffszeit ist stark von den Einhängeoptionen atime, noatime und relatime abhängig.) |
^ -mmin n | sucht nach Dateien, deren Inhalt vor n-1 bis n Minuten geändert wurde. (Achtung: andere Zählweise als bei -Xtime) |
^ -mmin +n | sucht nach Dateien, deren Inhalt älter als n Minuten ist. (Achtung: andere Zählweise als bei -Xtime) |
^ -mmin -n | sucht nach Dateien, deren Inhalt jünger als n Minuten ist. (gleiche Zählweise als bei -Xtime) |

==== Suchen mit find inkl. versteckter Dateinen/Ordner ====
<code bash>find $HOME -type d -iname ".*" -exec grep -Ir '<SUCHBEGRIFF>' {} \;</code>
===== Copy-Archive =====
<code bash>#!/bin/bash
# 

SRCDIR="<QUELL_PFAD>"
DESTDIR="<ZIEL_PFAD>"
HOSTNAME=`hostname`
FILENAME=<DATEI_NAME_OHNE_SUFFIX>

if [ $(date +%d) -eq "01" ]; then
        DIRMONTH="$(date -d'1 month ago' +%Y-%m)"
else
        DIRMONTH="$(date +%Y-%m)"
fi

DAYARCHIVENAME="${DESTDIR}/${DIRMONTH}/$(date -d'1 day ago' +%Y-%m-%d).${HOSTNAME}.${FILENAME}"
LOGTS="$(date "+%b %d %Y %H:%M:%S")"
TMPFILE="/tmp/${FILENAME}.tmp"

BINFIND=`which find`
BINTAR=`which tar`
BINGZIP=`which gzip`

ls ${SRCDIR} > ${TMPFILE}

cd ${SRCDIR}

if [ -s ${TMPFILE} ]; then

sleep $[ ( $RANDOM % 10 )  + 1 ]s

if [ ! -d "${DESTDIR}/${DIRMONTH}" ]; then
        echo "${LOGTS} erstelle ${DESTDIR}/${DIRMONTH}"
        mkdir ${DESTDIR}/${DIRMONTH}
        chmod 777 ${DESTDIR}/${DIRMONTH}
fi

        if [ -e "${DAYARCHIVENAME}.tar.gz" ]; then
                echo "${LOGTS} WARNUNG: Zielarchiv existiert bereits. Sichere nichts!"
        else
                if grep -qs '/datensicherung' /etc/mtab; then
                        #echo "${LOGTS} It's mounted."
                        echo -n
                else
                        echo "${LOGTS} WARNUNG: Ziel nicht gemounted. Versuche mount!"
                        mount /datensicherung
                fi

                echo "${LOGTS} Archiv mit Daten wird geschrieben"
                ${BINTAR} cvzf "${DAYARCHIVENAME}.tar.gz" `cat ${TMPFILE}` 1> /dev/null

                echo "${LOGTS} loesche gesicherte Quelldaten"
                xargs rm < ${TMPFILE}
        fi
else
        echo "${LOGTS} nichts zum Sichern vorhanden"
fi

rm ${TMPFILE}</code>

===== Copy Big-Data =====
<code bash>#!/usr/bin/env bash
#
#
#

export DIRLIST=dir.list

export SRC=<PFAD_ZU_QUELLE>
export DEST=<PFAD_ZU_ZIEL>

export LOG=${DIRLIST}.log

echo  "sync.sh started at `date`" >> ${LOG} 2>> ${LOG};

for elem in `cat ${DIRLIST}`; do
        echo "" >> ${LOG} 2>> ${LOG};
        echo "" >> ${LOG} 2>> ${LOG};
        echo "" >> ${LOG} 2>> ${LOG};
        echo "+++ starting at `date` syncing" $elem  >> ${LOG} 2>> ${LOG};
        rsync -a --bwlimit=5000 --stats ${SRC}/$elem ${DEST} >> ${LOG} 2>> ${LOG};
done

echo  "sync.sh finished at `date`" >> ${LOG} 2>> ${LOG};

exit 0;
</code>

===== CD-Copy-ISO =====
<code bash>#!/bin/bash

# Variablen
#MNTDIR=
#SRC=
DEST=/data/roe
MOUNTTIMEOUT=30

#eject # Laufwerk oeffnen falls nicht bereits geoeffnet

# Programmschleife startet
while true; do
 
  # Medien einlegen 
  echo Medium einlegen und DVD Nr. eingeben
  
  while true; do
    read -p "DVD Nummer:" MEDIENNR  # Abfrage: Mediennummer
    
    if [[ $MEDIENNR =~ ^exit|quit$ ]] ; then
      exit 0
    fi

    if ! [[ $MEDIENNR =~ ^[0-9]+$ ]] ; then
      tput setaf 1 # http://en.wikipedia.org/wiki/Tput
      echo Nur Zahlen erlaubt
      tput sgr0
      continue
    else
      break
    fi
  done  
  
  date "+%d.%m.%y %H:%M:%S"
  
  WORKDIR=$DEST/$MEDIENNR
  
  if [ -d "$WORKDIR" ]; then
    tput setaf 1
    echo Directory $WORKDIR exisitert bereits
    tput sgr0
    read -p "Enter to continue"
    continue
  fi  
   
  eject -t
  echo mounte Medium ... Einen Augenblick bitte

  # Medium mounten mit Fehlerkontrolle
  COUNTER=1
  for i in `seq 1 $MOUNTTIMEOUT`; do
    if  mount|grep -q sr0; then
      break
    else
      let COUNTER=COUNTER+1
      echo -n .
      sleep 1
    fi
  done
  
  echo # Zeilenumbruch nach Progressbar
  
  if [[ COUNTER -gt $MOUNTTIMEOUT ]]; then
    tput setaf 1
    echo Medium ist nicht mountbar!
    tput sgr0
    tput bel
    read -p "Enter to continue"
    eject
    continue 
  fi

  # Medium gefunden
  MEDIUMNAME=$(ls /media)
  MEDIUMMOUNTPATH=$(mount | grep sr0 | grep -Eo "/media(.*) type" | sed 's/ type//')
  
  echo Workdir: $WORKDIR
  echo Medienname: $MEDIUMNAME
  echo Mountpath: $MEDIUMMOUNTPATH
  
  mkdir -p "$WORKDIR/$MEDIUMNAME"
  
  echo md5sum des medium nach $WORKDIR/md5_medium.md5
  #cfv -rr -C -t md5 -q -f "$WORKDIR/md5_medium.md5" "$MEDIUMMOUNTPATH"
  #cat "$WORKDIR/md5_medium.md5" |  grep --only-matching '^[0-9a-f]*' | sort > "$WORKDIR/md5_medium.md5"
  find "$MEDIUMMOUNTPATH/" -type f -print0 | while read -d $'\0' -r file ; do 
    md5sum "$file" | grep -o '^[0-9a-f]*' >> "$WORKDIR/md5_medium.tmp"
  done
  cat "$WORKDIR/md5_medium.tmp" | sort > "$WORKDIR/md5_medium.md5"
  
  # Daten von Medium in Workdir kopieren
  echo "Daten von Medium nach $WORKDIR/$MEDIUMNAME kopieren"
  #touch "$WORKDIR/$MEDIUMNAME"/foo
  cp -ru "$MEDIUMMOUNTPATH/"* "$WORKDIR/$MEDIUMNAME"

  echo md5sum der kopierten Daten nach $WORKDIR/md5_copy.md5
  #cfv -rr -C -t md5 -q -f "$WORKDIR/md5_copy.md5" "$WORKDIR/$MEDIUMNAME"
  #cat "$WORKDIR/md5_copy.md5" |  grep --only-matching '^[0-9a-f]*' | sort > "$WORKDIR/md5_copy.md5"
  find "$WORKDIR/$MEDIUMNAME/" -type f -print0 | while read -d $'\0' -r file ; do 
    md5sum "$file" | grep -o '^[0-9a-f]*' >> "$WORKDIR/md5_copy.tmp"    
  done
  cat "$WORKDIR/md5_copy.tmp" | sort > "$WORKDIR/md5_copy.md5"
  
  echo Vergleich von md5_medium.md5 und md5_copy.md5
  DIFFRESULT=$(diff "$WORKDIR/md5_medium.md5" "$WORKDIR/md5_copy.md5")
  
  echo # leerzeile ueber Ergebnis
  
  ENDTIME=$(date "+%d.%m.%y %H:%M:%S") 
  if [ "$DIFFRESULT" != "" ]; then 
    # ungleich
    tput setaf 1 # color red
    echo $ENDTIME MD5 Hash unterschiedlich
  else
    # gleich
    tput setaf 2 # color green
    echo $ENDTIME MD5 Hash identisch
    rm "$WORKDIR/md5_medium.tmp"
    rm "$WORKDIR/md5_copy.tmp"
  fi
  tput sgr0
  echo # leerzeile unter Ergebnis
  
  tput bel

  eject # Medium auswerfen

done # Schleife ende
</code>

===== Datenverteilung mit scp =====
Das Tool ist ursprünglich wegen einer einfacheren Verteilung von Konfigurationseinstellungen für [[linux:nagios:nrpe|NRPE]] entstanden.
Damit das ganze funktioniert, erstellt man sich zunächst einer Ordnerstruktur.
  mkdir -p <WORKDIR> <WORKDIR>/aktuell <WORKDIR>/neu

Jetzt benötigt man noch einen RSA-PublicKey für die passwordlose authentifizierung an einem SSH-Host -> siehe [[linux:ssh_ohne_password|Ssh Ohne Password]].

Nun eine kleine ANLEITUNG
<code>## 
##
## Anleitung zum Verteilen neuer Einstellungen in der NRPE Konfiguration
##
##


1.      Patch erstellen
1.1     "nrpe.cfg" von Ordner "neu" nach "aktuell" kopieren
1.2     Änderungen in die "nrpe.cfg" im Ordner "neu" vornehmen
1.3     Befehl ausführen: diff -u -r -N aktuell/ neu/ > nrpe.cfg.patch
1.4     Pfade in der neuen Patch-Datei umbenennen:
                --- aktuell/nrpe.cfg
                +++ neu/nrpe.cfg
umbenennen in
                --- ./nrpe.cfg
                +++ ./nrpe.cfg

2.      Konfiguration verteilen
2.1     Datei "servers" ggf. anpassen ( Neue Eintraege wie folgt: "<HOSTNAME>.<DOMAIN>.<TLD>|0" )
2.2     Datei "rollout_newnrpeCFG.sh" ausführen und Anweisungen befolgen</code>

Man erstelle sich also eine Datei namens ''servers'' und fülle diese mit den Zielservern gefolgt von einer pipe <key>|</key> und der Zahl "0".
Beispiel:
  vi <WORKDIR>/servers
Inhalt:
<code><HOSTNAME1>.<DOMAIN>.<TLD>|0
<HOSTNAME2>.<DOMAIN>.<TLD>|0</code>

Die Zahl steuert das Programm an eine Verbindungsprüfung zum Zielhost durchzuführen. Wenn die Verbindung einmal erfolgreich war und der ssh-RSA-Pub-Key an den Zielhost kopiert wurde, setzt das Programm diese Zahl auf "1" und prüft beim nächsten mal nicht mehr.

Nun erstellt man sich die Datei ''rollout_newnrpeCFG.sh'' mit folgendem Inhalt (Die Variablen oben sind jew. anzupassen):
<code bash>#!/bin/bash

WORKDIR=/data/nagiosclients/NRPE/config
NAGIOSCFGDIR=/usr/local/nagios/etc
SSHUSER=root
SSHRSA=/root/.ssh/id_rsa_ng1
AUTHKEYSFILE=/root/.ssh/authorized_keys
DAEMONNAME=nrpe
SERVERSFILE=$WORKDIR/servers

#####
## NOTHING TO CHANGE FROM HERE!!!
#####

### Function for copying SSH-RSA Key
function rsaright {
  echo "Dem PC: $TARGETSVR wird aktuell nicht vertraut, oder das Authenticationfile existiert nicht."
  echo "kopiere öffentlichen RSA-Key"
  ssh-copy-id -i $SSHRSA.pub $SSHUSER@$TARGETSVR
}

### Function to check SSH-Connection with Targetsvr
function sshstatechange {
  if [ ! $TARGETSVR ]; then
    echo "kein Servername angegeben"
    exit 1
  fi
}

function sshconnection {
  ### SSH-Connection authenticated by RSA-KEY OK?
  SSHCONNECT="ssh -n -i $SSHRSA $SSHUSER@$TARGETSVR"
  sshstatechange
  ### Check if Server has been authorized
  grep "^$TARGETSVR|0" $SERVERSFILE > /dev/null 2>&1
  if [ $? -eq 0 ]; then
    rsaright
    ### Check if localhost inserted in "authorized_keys"
      $SSHCONNECT "cat $AUTHKEYSFILE |grep root@ng1" > /dev/null 2>&1
      if [ $? -eq 0 ]; then
        echo "Dem Zielserver wird vertraut, man kann sich per Passphrase authentifizieren."
        sed -i "s/^$TARGETSVR|[0-9]\+/$TARGETSVR|1/g" $SERVERSFILE > /dev/null 2>&1
      else
        rsaright
        sed -i "s/^$TARGETSVR|[0-9]\+/$TARGETSVR|1/g" $SERVERSFILE > /dev/null 2>&1
      fi
  else
    echo ######
    echo ## Neuer Durchlauf
    echo ######
    echo
    echo "SSH Verbindung per Passphrase hergestellt."
    echo "Verarbeite Script auf $($SSHCONNECT hostname -s)"
  fi
}

function nrpenewcfg {
  SSHCONNECT="ssh -n -i $SSHRSA $SSHUSER@$TARGETSVR"
  NRPEBACKUP=`$SSHCONNECT "ls $NAGIOSCFGDIR/*.bak|sed 's/.*\///g'"`
  NRPEPID=`$SSHCONNECT "pgrep nrpe"`
  ### "nrpe.cfg" Backup
  echo ">sichere alte nrpe Konfiguration"
  $SSHCONNECT "cp $NAGIOSCFGDIR/nrpe.cfg $NAGIOSCFGDIR/nrpe.cfg.bak"
  NRPEBACKUP=`$SSHCONNECT "ls $NAGIOSCFGDIR/*.bak|sed 's/.*\///g'"`
  echo "Erstellte Sicherungsdatei ist $NRPEBACKUP."

  ### patching "nrpe.cfg"
  echo
  echo ">patche 'nrpe.cfg'"
  scp -i $SSHRSA $WORKDIR/$PATCHFILE $SSHUSER@$TARGETSVR:$NAGIOSCFGDIR > /dev/null 2>&1
  NRPEPATCHFILE=`$SSHCONNECT "ls $NAGIOSCFGDIR/*.patch|sed 's/.*\///g'"`
  echo "Datei $NRPEPATCHFILE kopiert."
  echo
  $SSHCONNECT "cd $NAGIOSCFGDIR && patch -p1 < ./$PATCHFILE"

  ### restart nrpe Daemon
  echo
  echo "Die nrpe Daemon PID lautet $NRPEPID"
  echo "Starte den rnpe Daemon neu."
  $SSHCONNECT "/etc/init.d/$DAEMONNAME restart"
  sleep 1
  NRPEPID=`$SSHCONNECT "pgrep nrpe"`
  echo "Die neue nrpe Daemon PID lautet $NRPEPID"
  echo
  echo Ende
  echo
}

clear

echo
echo
echo "Dieses Script kopiert die nrpe Konfigurationsdatei auf den überwachten Zielserver"
echo "und startet den nrpe Daemon neu"
echo

read -t 20 -p "Name der Patch-Datei aus $WORKDIR angeben: " PATCHFILE
read -t 10 -p "Konfiguration auf alle Server (aus '$SERVERSFILE') verteilen? [ja|nein] " ALL_SERVERS

case "$ALL_SERVERS" in
        Ja|ja|J|j|"") echo "Ok los geht's"
                while read TTARGETSVR; do
                        TARGETSVR=$(echo $TTARGETSVR|sed 's/|.*//g')
                        sshconnection
                        echo
                        echo
                        nrpenewcfg
                done < $SERVERSFILE
            ;;
        Nein|nein|N|n) read -t 20 -p "Servername eingeben (inkl. DOMAIN): " TARGETSVR
                sshconnection
                        echo
                        echo
                nrpenewcfg
            ;;
            *) echo "Unbekannter Parameter"
            ;;
esac</code>

===== Rsync mit MD5-Hash Datenvergleich =====
Mit dieser Scriptsammlung kann man Daten von einem Quellserver zu einem Zielserver synchronisieren und danach von den Daten einen md5-Hash erstellten.
Dieser Hash wird dann verglichen und das Ergebnis per Mail verschickt.

Scriptsammlung: {{:rsync-md5.zip|}}

===== While read line =====
<code bash>while read line ; do
  echo ${line}
  <COMMAND>
done < <FILENAME></code>

===== USB-Device =====
So findet man heraus, welchen Device-Namen Ubuntu für, an einem bestimmten USB-PORT angeschlossenen, USB-Stick oder Festplatte verwendet.
  ls /sys/bus/usb/devices/<USB_ROOT_HUB>-<HUB_PORT>/<USB_ROOT_HUB>-<HUB_PORT>:*/host*/target*/*/block

===== stats =====
Statistik einer Ordnerstrucktur erstellen:
<code bash>#!/bin/bash
#
FIND="`which find`"
STAT="`which stat`"

echo "Geben Sie einen Dateipfad an: "
read DIRPATH

echo ${DIRPATH} > ./dirlist
DIREND="`awk -F/ '{print $NF}' ./dirlist`"
STATFILE="stat-${DIREND}.txt"
DATE_FILE="`ls -l ${STATFILE}|awk -F " " '{print $6"_" $7"_" $8}'`"

if [ -f ${STATFILE} ] ; then
  mv ${STATFILE} ${STATFILE}_${DATE_FILE}
fi

${FIND} ${DIRPATH} -exec ${STAT} {} \; > ${STATFILE}</code>

===== Logrotation files to 1 File =====
Wenn logrotate die Log-Dateien umbenennt und auch ggf. komprimiert und man aus diesen Dateien eine machen möchte, kann man das mit diesem 
Scriptschnipsel machen.
Dazu erstellt man sich eine Datei ''files'', welche den ''ls'' Inhalt eines Ordners, in dem alle rotierten Dateien liegen, beinhaltet.
<code bash>cat files | while read line; do tar xfz $line -C <PFADE_ZU_TEMP_UNZIP_ORDNER>; cat <PFADE_ZU_TEMP_UNZIP_ORDNER>/<LOGDATEI_NAME> >> <AUSGABEDATEI_NAME>; done</code>

===== Switch Bandbreite =====
Diese Script fragt per SNMP einen Switch ab und berechnet die Bandbreite in einem angegebenen Zeitraum.
Die Benutzung des Scriptes wird ausgegeben, wenn das Script ohne Parameter gestartet wird.
<code bash>#!/bin/bash

pollPeriod=$1
switchip=$2
port=$3
snmp=".1.3.6.1.2.1.31.1.1.1.6" #IF-MIB::ifHCInOctets

if [ -z "${1}"  ]; then
  echo `tput setaf 1`Keine Parameter angegeben`tput sgr0`!
  echo
  echo Diese Programm berechnet die Auslastung eines Ports auf
  echo einem Switch in bps "("bits per second")".
  echo
  echo Es wird, per SNMP, der gleiche Werte zwei mal, in einem anzugebenden
  echo Zeitabstand, vom Switch zur Berechnung abgefragt.
  echo
  echo Usage:
  echo
  echo Befehl: ifOctets.sh
  echo
  echo mögliche Parameter:
  echo
  echo 1. Zeitabstand zu den 2 Utilization Messungen
  echo 2. welcher Switch -als IP oder DNS-Name
  echo 3. welcher Port auf dem Switch
  echo
  echo Beispiel:
  echo '"ifOctets.sh 192.168.0.1 5"'

  exit 0
fi

clear
echo
echo Berechne nach Formel:
echo
echo `tput bold`aktueller Wert "-" erster Wert "*" 8 "/" Zeitabstand`tput sgr0`
echo
echo Zum Beenden einfach die Taste "q" drücken.

keypress=''
while : ; do
  previous=`snmpget -c hpswitche -v 2c ${switchip} ${snmp}.${port}|awk '{ print $4 }'`
  sleep ${pollPeriod}
  current=`snmpget -c hpswitche -v 2c ${switchip} ${snmp}.${port}|awk '{ print $4 }'`

  echo Previous = ${previous}
  echo Current = ${current}
  echo PollPeriod = ${pollPeriod}
  echo

  bps=`bc -l <<< "scale=2; (${current}-${previous})*8/${pollPeriod}"`
  Mbps=`bc -l <<< "scale=2; ${bps}/1024/1024"`

  echo Ergebnis Port 23: `tput setaf 3`${bps}`tput sgr0` b"/"s
  echo "                  "`tput setaf 3`${Mbps}`tput sgr0` Mb"/"s

  read -t 1 -n 1 key
  if [[ ${key} = q ]]; then
    break
  fi
done</code>

===== nur gesetzte Einstellungen in Konfigurationsdateien anzeigen =====
Hier ein Beispiel anhand der ''php.ini''.
Grep filtert zunächst alle zeilen mit <key>;</key> und danach die daraus entstandenen Leerzeilen.
<code bash>cat /etc/php/7.0/fpm/php.ini|grep -v -E "^\;"|grep -v -E "^$"</code>

===== Ping mit Timestamp =====
<code bash>ping <IP_OR_HOSTNAME>|while read pong; do echo "$(date +%F_%X): $pong"; done</code>

===== Timestamp als Funktion =====
Aktuelle Timestamp vor jedes ''echo'' angeben.
<code bash>LOGTS () {
  date "+%b %d %Y %H:%M:%S"
}

echo "$(LOGTS): etwas passiert"
sleep 5
echo "$(LOGTS): etwas anderes passiert"</code>

===== Datum Berechnung =====
In folgendem Script wir die Dauer der Laufzeit berechnet.
<code bash>#!/bin/bash

# Aktueller Timestamp als Funktion
ts () {
  date "+%b %d %Y %H:%M:%S"
}

# SleepTimer ist random zwischen 1 und 10
st=$(( ( RANDOM % 10 )  + 1 ))

# Starttimestamp
startts=`date --utc --date "$(ts)" +%s`

echo "let's go"
echo $startts
sleep $st

# Endtimestamp
stopts=`date --utc --date "$(ts)" +%s`

echo $stopts
dauer=$(( $stopts-$startts ))

echo "Das Script hat $dauer Sekunden gedauert."
echo "ende"
</code>

===== USB-Device finden =====
Quelle: [[https://askubuntu.com/questions/1069457/get-name-and-device-file-path-of-usb-device-attached]]
<code bash>#!/bin/bash

for sysdevpath in $(find /sys/bus/usb/devices/usb*/ -name dev); do
    (
        syspath="${sysdevpath%/dev}"
        devname="$(udevadm info -q name -p $syspath)"
        
        [[ "$devname" == "bus/"* ]] || [[ "$devname" == "input/"* ]] || [[ "$devname" == "video0"* ]] || exit
        
        eval "$(udevadm info -q property --export -p $syspath)"
        [[ -z "$ID_SERIAL" ]] && exit
        
        busnum="$(udevadm info -a -p  $(udevadm info -q path -n /dev/$devname) | awk -F "==" '/busnum/ {gsub("\"","");print $2}' | head -1)"
        devnum="$(udevadm info -a -p  $(udevadm info -q path -n /dev/$devname) | awk -F "==" '/devnum/ {gsub("\"","");print $2}' | head -1)"
        bus_dev=${busnum}:${devnum}
        lsusb="$(lsusb -s $bus_dev)"
        
        echo "$lsusb - /dev/$devname"
    )
done</code>

===== Betriebssystem Installationsdatum =====
Verschiedene Betriebssysteme haben verschiedene Möglichkeiten das Installationsdatum zu zeigen, hier sind einige.
  * Erstellungsdatum der Partition "/" <code bash>sudo dumpe2fs $(findmnt / -no source) | grep 'Filesystem created:'</code>
  * älteste Datei unter "/etc" <code bash>ls -lct /etc | tail -1 | awk '{print $7, $6, $8}'</code>
  * älteste Datei unter "/var/log/installer" <code bash>ls --sort=t /var/log/installer -l | tail -n1</code>