staging.inyokaproject.org

#! /bin/bash
#
Laufwerke="/dev/sdb /dev/sdc /dev/sdd /dev/sde"
ArrayLw=$Laufwerke
AnzahlLaufwerke=4

COUNTER=0
while [  $COUNTER -lt $AnzahlLaufwerke ]; 
do
  ArrayNeu=${ArrayLw[COUNTER]}+"1"

  let COUNTER=COUNTER+1

echo ArrayNeu[COUNTER]
read
done

#! /bin/bash
#
Laufwerke="/dev/sdb /dev/sdc /dev/sdd /dev/sde"
ArrayLw=($Laufwerke)

for element in "${ArrayLw[@]}" 
do
  ArrayNeu+=("${element}1")
done

echo "${ArrayNeu[@]}"

Laufwerke="/dev/sdb /dev/sdc /dev/sdd /dev/sde"
ArrayNeu=($(printf "%s1 " $Laufwerke))
echo "${ArrayNeu[@]}"

echo "/dev/sd"{b,c,d,e}"1"

#! /bin/bash
#
cd ~
clear
tput setab 15 # Hintergrund Weiss
tput setaf 0 # Vordergrund Schwarz
clear
echo
read -p "Welchen Namen soll das RAID erhalten ? : $(tput setaf 1)" RaidName
tput setaf 0
echo
read -p "Soll das RAID verschlüsselt werden ? (j/n) : $(tput setaf 1)" Verschluesseln
tput setaf 0
echo
read -p "Welches RAID-Level soll erstellt werden (0/1/5/6) ? : $(tput setaf 1)" RaidLevel
tput setaf 0
echo
read -p "Wieviele Laufwerke sollen zum RAID-verbund gehören ? : $(tput setaf 1)" AnzahlLaufwerke
tput setaf 0
echo
read -p "RAID Laufwerke ?
(Schreibweise Beispiel : /dev/sdb /dev/sdc /dev/sdd) ? : $(tput setaf 1)" Laufwerke
tput setaf 0
echo
AnzahlSpareLaufwerke=0 #Wenn keine Spare-Laufwerke verwendet werden, dann "0" für mdadm
SpareLaufwerke=""      #Wenn keine Spare-Laufwerke verwendet werden, dann Leer-wert für mdadm
read -p "Wieviele Spare-Laufwerke sollen zusätzlich
zum RAID-verbund gehören ? : $(tput setaf 1)" AnzahlSpareLaufwerke
tput setaf 0
echo
if [ $AnzahlSpareLaufwerke -gt 0 ];
then
read -p "Spare-Laufwerke(e) ?
(Schreibweise Beispiel : /dev/sde /dev/sdf /dev/sdg) ? : $(tput setaf 1)" SpareLaufwerke
tput setaf 0
echo
fi
read -p "Die Grösse der Chunks in KiB (Standard : 512) ? : $(tput setaf 1)" ChunkGroesse
tput setaf 0
echo
read -p "Dateisystem Blockgrösse in Byte (Standard : 4096)
(sollte nur in ganz speziellen Fällen geändert werden) ? : $(tput setaf 1)" BlockGroesse
tput setaf 0
echo
read -p "Die Stride Grösse ?
(Standard : 512 KiB Chunk / (4096 Byte Dateisystem Blockgrösse / 1024) = 128 ) : $(tput setaf 1)" StrideGroesse
tput setaf 0
echo
echo "Die Stripe Breite."
echo "Bespiel : Ein RAID-6 verbund, bestehend aus insgesamt 8 Laufwerken :"
echo "8 Laufwerke wovon immer 2 Parity-Laufwerke"
echo "(bei RAID-5 und bei RAID-1 jeweils nur 1 Parity-Laufwerk) sein müssen,"
echo "ergibt 6 Nutzbare Laufwerke. Spare-Laufwerke zählen NICHT dazu !"
echo "128 KiB Stride Grösse * 6 Nutzbare Laufwerke = 768"
read -p "Stripe Breite ? : $(tput setaf 1)" StripeBreite
tput setaf 0
echo
clear
echo
echo "==================="
echo "= Zusammenfassung ="
echo "==================="
tput setaf 0
echo
echo "Hardware :"
echo "Zu dem neuen Verbund gehören insgesamt $(tput setaf 1)$AnzahlLaufwerke Laufwerke$(tput setaf 0) :"
echo "$(tput setaf 1)$Laufwerke$(tput setaf 0)"
if [ $AnzahlSpareLaufwerke -gt 0 ];
then
echo
echo "Zusätzlich werden noch $(tput setaf 1)$AnzahlSpareLaufwerke Spare-Laufwerk(e) $(tput setaf 0)hinzugefügt :"
echo "$(tput setaf 1)$SpareLaufwerke$(tput setaf 0)"
fi
case "$Verschluesseln" in
j|"")
echo
echo "Software :"
echo "Der neue $(tput setaf 1)RAID-$RaidLevel $(tput setaf 0)Verbund wird in $(tput setaf 1)$RaidName $(tput setaf 0)benannt und $(tput setaf 1)Verschlüsselt$(tput setaf 0)."
echo "Er wird auf auf $(tput setaf 1)/dev/mapper/$RaidName $(tput setaf 0)verlinkt werden."
;;
n)
echo
echo "Software :"
echo "Der neue $(tput setaf 1)RAID-$RaidLevel $(tput setaf 0)Verbund wird in $(tput setaf 1)$RaidName $(tput setaf 0)benannt"
echo "und auf $(tput setaf 1)/dev/md/$RaidName $(tput setaf 0)verlinkt werden."
;;
esac
echo
echo "Die Grösse der Chunks beträgt $(tput setaf 1)$ChunkGroesse KiB$(tput setaf 0)."
echo "Die Grösse der Dateisystem Blöcke beträgt $(tput setaf 1)$BlockGroesse Byte$(tput setaf 0)."
echo "Die Grösse der Strides beträgt $(tput setaf 1)$StrideGroesse KiB$(tput setaf 0)."
echo "Die Breite der Stripes beträgt $(tput setaf 1)$StripeBreite KiB$(tput setaf 0)."
echo
echo
echo "Ab hier werden Änderungen am System vorgenommen."
echo "------------------------------------------------"
echo
echo "Die Laufwerke die für den RAID-verbund ausgewählt wurden,"
echo "werden $(tput setaf 1)UNWIEDERHERSTELLBAR GELÖSCHT !$(tput setaf 0)"
echo
read -p "$(tput setaf 2)(w)eiter, $(tput setaf 3)(z)urück, $(tput setaf 1)(a)bbrechen$(tput setaf 0) ?  (w/z/a) : " antwort
case "$antwort" in
        a|"")
        tput sgr0
        clear
        echo
        echo "Das Programm wurde ohne Änderungen vorzunehmen beendet."
        echo
        exit 1
        ;;
        z)
        unset RaidName
        unset Verschluesseln
        unset RaidLevel
        unset AnzahlLaufwerke
        unset Laufwerke
        unset AnzahlSpareLaufwerke
        unset SpareLaufwerke
        unset ChunkGroesse
        unset BlockGroesse
        unset StrideGroesse
        unset StripeBreite
        
        # Rücksprung Zeile 4. WIE ??
        ;;
        w)
        ;;
esac

ArrayLaufwerke=($Laufwerke)
COUNTER=0
cntr=0
while [  $COUNTER -lt $AnzahlLaufwerke ]; do
cntr=$((cntr+1))
clear
echo
echo "Vorbereitung von Laufwerk : $(tput setaf 1)$cntr/$AnzahlLaufwerke - ${ArrayLaufwerke[COUNTER]}$(tput setaf 0)"
echo "=========================================="
echo
echo "$(tput setaf 1)Das Laufwerk wird gelöscht...$(tput setaf 0)"
# Löschen durch überschreiben mit Nullen :
dd if=/dev/zero bs=1M status=progress of=${ArrayLaufwerke[COUNTER]}
# GPT-Partitionstabelle erstellen :
parted -s ${ArrayLaufwerke[COUNTER]} mklabel gpt
# Leere Partition erstellen :
parted -s -a optimal -- ${ArrayLaufwerke[COUNTER]} mkpart RaidDevice$COUNTER 2048s -16384s
# Partitions-Flag "linux_raid_member" setzen :
parted -s ${ArrayLaufwerke[COUNTER]} set 1 raid on
# Datenträger Zufalls-GUID erstellen :
sgdisk -G ${ArrayLaufwerke[COUNTER]}
sync
let COUNTER=COUNTER+1
done

if [ $AnzahlSpareLaufwerke -gt 0 ];
then
clear
ArraySpareLaufwerke=($SpareLaufwerke)
COUNTER=0
cntr=0
while [  $COUNTER -lt $AnzahlSpareLaufwerke ]; do
cntr=$((cntr+1))
clear
echo
echo "Vorbereitung von Spare-Laufwerk : $(tput setaf 1)$cntr/$AnzahlSpareLaufwerke - ${ArraySpareLaufwerke[COUNTER]}$(tput setaf 0)"
echo "================================================"
echo
echo "$(tput setaf 1)Das Laufwerk wird gelöscht...$(tput setaf 0)"
dd if=/dev/zero bs=1M status=progress of=${ArraySpareLaufwerke[COUNTER]}
parted -s ${ArraySpareLaufwerke[COUNTER]} mklabel gpt
parted -s -a optimal -- ${ArraySpareLaufwerke[COUNTER]} mkpart RaidSpareDevice$cntr 2048s -16384s
parted -s ${ArraySpareLaufwerke[COUNTER]} set 1 raid on
sgdisk -G ${ArraySpareLaufwerke[COUNTER]}
sync
let COUNTER=COUNTER+1
done
fi

echo
echo "Das Vorbereiten aller Laufwerke ist beendet."
echo
unset antwort
read -p "$(tput setaf 2)(w)eiter, $(tput setaf 1)(a)bbrechen$(tput setaf 0) (w/a) ? " antwort
case "$antwort" in
        a|"")
        tput sgr0
        clear
        echo
        echo "Das Programm wurde beendet."
        echo
        exit 1
        ;;
        w)
        ;;
esac

# Den Laufwerken eine "1" anhängen für mdadm (z.b. /dev/sdc nach /dev/sdc1) :
ArrayLw=($Laufwerke)
for element in "${ArrayLw[@]}"
do
  Lw+=("${element}1")
done

if [ $AnzahlSpareLaufwerke -gt 0 ];
 then
   ArraySpLw=($SpareLaufwerke)
   for element in "${ArraySpLw[@]}"
   do
     SpLw+=("${element}1")
   done
else
SpLw=""
fi

clear
echo
echo "Erstelle neues $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volume : $(tput setaf 1)/dev/md/$RaidName$(tput setaf 0)"
echo "========================================================="
echo
# Das RAID Volume mit mdadm erstellen :
mdadm --create /dev/md/$RaidName --auto md --chunk=$ChunkGroesse --verbose --level=$RaidLevel --raid-devices=$AnzahlLaufwerke ${Lw[@]} --spare-devices=$AnzahlSpareLaufwerke ${SpLw[@]}
sync
echo
echo "Erstellen des neuen $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volumes beendet."
echo "Eingabetaste drücken zum fortsetzen."
read

case "$Verschluesseln" in
j|"")
clear
echo
echo "Einrichten der Verschlüsselung des $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volumes."
echo "=================================================="
echo
echo "Passwort festlegen und Volume Verschlüsseln :"
# Das RAID Volume mit LUKS Verschlüsseln :
cryptsetup luksFormat -c aes-xts-plain64 -s 512 -h sha512 /dev/md/$RaidName
sync
echo
echo "Verschlüsseltes Volume öffnen :"
# Das Verschlüsselte RAID Volume zur weiterbearbeitung öffnen :
cryptsetup luksOpen /dev/md/$RaidName $RaidName
echo
echo
echo "Eingabetaste drücken zum fortsetzen."
read
clear
echo
echo "Formatiere das Verschlüsselte $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volume."
echo "============================================"
echo
# Das Verschlüsselte RAID Volume auf EXT4 Formatieren :
mkfs -t ext4 -v -L $RaidName -b $BlockGroesse -E stride=$StrideGroesse,stripe-width=$StripeBreite /dev/mapper/$RaidName
# Die Dateisystem-Fehlerprüfung auf alle 3 Mounts einstellen :
tune2fs -c3 -C1 /dev/mapper/$RaidName
sync
echo
echo "Verschlüsseln und Formatieren des $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volumes beendet."
echo "Eingabetaste drücken zum fortsetzen."
read
;;
n)
clear
echo
echo "Formatiere das $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volume."
echo "============================"
echo
# Das RAID Volume auf EXT4 Formatieren :
mkfs -t ext4 -v -L $RaidName -b $BlockGroesse -E stride=$StrideGroesse,stripe-width=$StripeBreite /dev/md/$RaidName
tune2fs -c3 -C1 /dev/md/$RaidName
sync
echo
echo "Formatieren des $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volumes beendet."
echo "Eingabetaste drücken zum fortsetzen."
read
;;
esac

clear
echo "Das $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volume wird im Hintergrund aufgebaut..."
echo
echo "Eingabetaste drücken um die Fortschrittsanzeige einzublenden,"
echo "STRG+C drücken um die Fortschrittsanzeige wieder zu beenden."
read
clear
tput setaf 1
clear
# Den BUILD-Fortschritt vom RAID Volume anzeigen lassen :
watch -n 1 mdadm --detail /dev/md/$RaidName
clear
tput setaf 0
clear
echo
read -p "Das $(tput setaf 1)RAID-$RaidLevel$(tput setaf 0) Volume $(tput setaf 1)/dev/md/$RaidName$(tput setaf 0) in das Benutzerverzeichnis einbinden,
die Zugriffsrechte anpassen und in die $(tput setaf 1)/etc/fstab$(tput setaf 0) eintragen? (j/n) : " antwort
case "$antwort" in
        j|"")

          case "$Verschluesseln" in
          j|"")
          # Verschlüsseltes RAID Volume
          benutzer=$whoami # $whoami  liefert den Benutzer nicht zurück.  - Bug ?? -
          mkdir /home/$benutzer/$RaidName
          mount -t ext4 /dev/mapper/$RaidName /home/$benutzer/$RaidName
          chown -R /home/$benutzer/$RaidName $benutzer
          chgrp -R /home/$benutzer/$RaidName $benutzer
          echo /dev/mapper/$RaidName /home/$benutzer/$RaidName ext4 defaults,user,noauto 0 2 >> /etc/fstab
          ;;
          n)
          # Unverschlüsseltes RAID Volume
          benutzer=$whoami
          mkdir /home/$benutzer/$RaidName
          mount -t ext4 /dev/md/$RaidName /home/$benutzer/$RaidName
          chown -R /home/$benutzer/$RaidName $benutzer
          chgrp -R /home/$benutzer/$RaidName $benutzer
          echo /dev/md/$RaidName /home/$benutzer/$RaidName ext4 defaults,user 0 2 >> /etc/fstab
          ;;
          esac
          
        ;;
        n)
        tput sgr0
        clear
        echo
        echo "Programm beendet."
        echo
        exit 1
        ;;
esac
tput sgr0
clear
echo
echo "Programm beendet."
echo

[[ $a =~ [0-9]+ ]] && echo Zahl || echo keine Zahl

$ sudo env | fgrep USER
USER=root
SUDO_USER=rklm

$ pstree -us $$ | egrep -o '\([^)]+\)' | fgrep -vx '(root)' | sed -n '$s/^(//;s/)$//p'
rklm

benutzer=$(pstree -us $$ | egrep -o '\([^)]+\)' | fgrep -vx '(root)' | sed -n '$s/^(//;s/)$//p')

#! /bin/bash
#
benutzer=$(SUDO_USER)
echo "Der Benutzername ist :" $benutzer

#!/bin/bash
echo "Der Benutzername ist :"  "$SUDO_USER"

foo="bar"
echo "${foo}bar"  # hier interessiert uns der Wert, der der Variablen foo zugewiesen wurde
output=$(echo "${foo}bar") # hier interessiert uns die Ausgabe von echo "${foo}",
                        # die der Variable output als Wert zugewiesen wird
echo "${output}a"

declare -i n1=5
declare -i n2=10
echo $(( n1 * n2 - n1 ))

for in {1..100..2}
do
  echo $i
done