Scriptschnipsel

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

• Zahlen-Arrays
  

  {1..5}

• Variablen werden nicht in Abschnitten, welche mit singel-Quotes (') definiert sind, übergeben/umgesetzt. Lösung ist eine aufteilen der Abschnitte
  Funktioniert nicht
  

  'BEFEHLSCODE "PARAMETER" ${VARIABLE} "PARAMETER" BEFEHLSCODE "PARAMETER" '

  Funktoniert
  

  'BEFEHLSCODE "PARAMETER"' ${VARIABLE} '"PARAMETER" BEFEHLSCODE "PARAMETER" '

Quelle: http://www.linux-praxis.de/linux1/shell2_5.html

if [ <BEDINGUNG> == "y" -o <BEDINGUNG> == "Y" ]; then
  <BEFEHL>
fi

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.

read -p "Wollen Sie etwas tun? [y|Y] ANTWORT
ANTWORT=${ANTWORT:=Y}
if [ $ANTWORT == "y" -o $ANTWORT == "Y" ]; then
  <BEFEHL>
else
  exit
fi

Erstellen eines Ordners wenn er nicht existiert.

if [ ! -d "<ORDNER_NAME>" ]; then
  <BEFEHL>
else
  exit
fi

Prüfen ob ein Befehl existiert.

if [ -x $(command -v <BEFEHL>)  ]; then
  echo "existiert nicht"
fi

Das : Zeichen hinter den Parametern (H,C,T) sagt aus, dass zu dem Parameter noch Argumente angegeben werden müssen.

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

#!/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

find /Pfad/zu/Dateien -name "*.jpg" -exec cp --parents {} /Pfad/zu/Ziel \;

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

siehe backupscript

diff -rqy <DIR1> <DIR2>

ls -d <PFAD> | sed 's!/$!!'

ls -l <PFAD> | awk '{print $9}'

oder eine einzelne Datei

ls -l <PFAD> | awk '{print $9}'|grep <DATEINAME>

#!/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}

#!/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

Dateien suchen und in einem bestimmten Zeitraum löschen.

• Zeitraum
  • Datumsformat: jjjj-mm-dd

    touch --date "<JÜNGSTES_DATUM>" end
    touch --date "<ÄLTESTES_DATUM>" start

  • Dateien suchen und löschen

    find <VERZEICHNIS> -type f -newer <PFAD>/start -not -newer <PFAD>/end -exec rm -rf {} \;

• löschen wenn n Tage älter

  find <PFAD>/* -mtime +n -exec rm {} \;

Bedeutung Parameter (Quelle: https://wiki.ubuntuusers.de/)

find $HOME -type d -iname ".*" -exec grep -Ir '<SUCHBEGRIFF>' {} \;

#!/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}

#!/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;

#!/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

Das Tool ist ursprünglich wegen einer einfacheren Verteilung von Konfigurationseinstellungen für 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 Ssh Ohne Password.

Nun eine kleine ANLEITUNG

## 
##
## 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

Man erstelle sich also eine Datei namens servers und fülle diese mit den Zielservern gefolgt von einer pipe | und der Zahl „0“.
Beispiel:

vi <WORKDIR>/servers

Inhalt:

<HOSTNAME1>.<DOMAIN>.<TLD>|0
<HOSTNAME2>.<DOMAIN>.<TLD>|0

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):

#!/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

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 ; do
  echo ${line}
  <COMMAND>
done < <FILENAME>

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

Statistik einer Ordnerstrucktur erstellen:

#!/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}

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.

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

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.

#!/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

Hier ein Beispiel anhand der php.ini.
Grep filtert zunächst alle zeilen mit ; und danach die daraus entstandenen Leerzeilen.

cat /etc/php/7.0/fpm/php.ini|grep -v -E "^\;"|grep -v -E "^$"

ping <IP_OR_HOSTNAME>|while read pong; do echo "$(date +%F_%X): $pong"; done

Aktuelle Timestamp vor jedes echo angeben.

LOGTS () {
  date "+%b %d %Y %H:%M:%S"
}
 
echo "$(LOGTS): etwas passiert"
sleep 5
echo "$(LOGTS): etwas anderes passiert"

In folgendem Script wir die Dauer der Laufzeit berechnet.

#!/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"

Quelle: https://askubuntu.com/questions/1069457/get-name-and-device-file-path-of-usb-device-attached

#!/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