Topic 103 - GNU und Unix Kommandos

Topic 103.1 - Work on the command line

Siehe Seite 89 ff

Wir unterscheiden zwei Arten von Variablen:

  • Umgebungsvariablen: großgeschrieben, werden automatisch vererbt

    • BSP: ‘echo $PATH’

    • BSP: ‘echo $PS2’

  • Shellvariablen werden manuell deklariert, bei Bedarf können sie exportiert werden

    • BSP: ‘myname="Axel Pemmann" ; echo $myname’

    • Kindterminal starten: ‘gnome-terminal &’

    • Wo ist diese Variable denn aber in diesem neuen Terminal? Nicht vorhanden! Sie wurde nicht exportiert.

    • Daher schließen wir das Terminal und starten es erst nach dem Exportieren der Variablen:

      exit
      export myname
      gnome-terminal &

Zur Kontrolle der Variablen:

  • Die umfangreichsten Ausgaben liefert 'set' (alle Shell- und Umgebungsvariablen):

    => set | grep myname
  • Nur die Umgebungsvariablen liefert 'env':

    => env | grep PATH

Wenn nun die selbst erzeugte Shellvariabale 'myname' auftaucht, dann wurde sie exportiert, was man aber wieder mit

=> export -n myname

zurücknehmen kann.

Ganz und gar entfernt werden kann diese eigene Variable am Schluss mit:

=> unset myname

Nicht nur für LPI wichtig: Skripte, die in der aktuellen Shellumgebung eingelesen und aktiv gesetzt werden sollen, müssen mit

=> source myscript

bzw. alternativ mit einem Punkt, worauf ein Leerzeichen folgt,

=> . myscript

ausgeführt werden…​

Konfigurationsdateien der Shell

Motivation: Viele Einstellungen lassen sich temporär vornehmen, um sie festzuschreiben, müssen die verschiedensten Konfigurationsdateien editiert werden.

Unterscheidung zwischen alten Shells und der neuen Standardshell: bash

Alte Shells

Beispiele (siehe auch /etc/shells): /bin/sh, /bin/ksh

Seite 90/ 91: Wichtiges Unterscheidungskriterium: Welche Dateinamen beinhalten NICHT den Namen 'bash'?

=>  /etc/profile
=> ~/.profile

Startup-Dateien für User-Profiles

a) Systemweit

  • /etc/profile - Wird als erstes nach dem User-Login abgearbeitet, allgemein für alle Shells, z.B. Variablen PATH und PS1, evl auch umask

  • /etc/bashrc - Wird als nächstes als Konfigurationsdatei speziell für die bash abgearbeitet, z.B. PS1 (für Promptbildung der bash)

b) Benutzerdefiniert (Diese Dateien überschreiben die systemweiten Einstellungen)

  • ~/.profile - Wird einmalig nach dem Login nach dem Ausführen der /etc/profile abgearbeitet, Verwendung wie eben diese Datei, in der Vergangenheit war sie auch für die bash zuständig.

  • \~/.bash_profile - Spezielle bash-Startupdatei, die die alte ~/.profile ersetzt, wird nur einmal abgearbeitet

  • \~/.bash_login - Entspricht der ~/.bash_profile, wenn sie nicht existiert wird diese nämlich an dessen Stelle ausgeführt

  • ~/.bash_logout - Optionale Datei, die Befehle beim Logout wie clear (Bildschirm löschen) ausführt

  • ~/.bashrc - Eine weitere, alte bash-Startupdatei, sie wird jedesmal mit einer neuen bash-Instanz abgearbeitet (neues Terminal öffnen), z.B. Aliase, PS1 (Farbprompt)

man-Pages

⇒ Seite 96 ff

ZIEL: Sich selber weiterhelfen können…​ mit dem Online-Manuals (Online = werden mit den Paketen ausgeliefert)

Man-Pages sind Kurzbeschreibungen von Kommandos und Dateien, denen oft Beispiele fehlen. (Von Programmierern für Programmierer), deswegen gibt es die HOWTOs im Internet bzw. als Paket nachinstallieren.

Benutzung

  • Aufruf: man <KOMMADO/LIBRARY/KONFIGDATEI>

  • Navigation (gemäß less-Pager):

    • Cursortasten, Enter, Leertaste

    • F (forward), B (backward)

    • G (go to the end), g (go to the begin)

  • Suchen:

    • Vorwärts (nach unten): /<PATTERN>, Weitersuchen: n (next), Rückwärts nach oben suchen: N (Next)

    • Rückwärts (nach oben): ?<PATTERN>, Weitersuchen: n (next), Rückwärts nach unten suchen: N (Next)

  • Beenden: q (quit)

Funktionsweise

⇒ man "manpath"

Eine Konfigdatei, legt die Pfade fest: '/etc/manpath.config'

tux@deb8-2:~$ grep MANDB /etc/manpath.config
# MANDB_MAP      global_manpath             [relative_catpath]
MANDB_MAP        /usr/man                   /var/cache/man/fsstnd
MANDB_MAP        /usr/share/man             /var/cache/man
MANDB_MAP        /usr/local/man             /var/cache/man/oldlocal
MANDB_MAP        /usr/local/share/man       /var/cache/man/local
MANDB_MAP        /usr/X11R6/man             /var/cache/man/X11R6
MANDB_MAP        /opt/man                   /var/cache/man/opt
tux@deb8-2:~$

Weiterhin wird die Variable 'MANPATH' abgearbeitet, falls sie vorhanden ist.

Die man-Pages liegen komprimiert vor, beim Aufruf werden sie unter '/var/cache/man' dekomprimiert abgelegt. Die tatsächliche Pfade ausgeben: manpath -c

Der Cache lässet sich mit catman bereinigen, den Suchindex für 'apropos' kann man mit mandb neu aufbauen.

Die man-Pages werden in sogenannten Abschnitten kategorisiert, siehe 'man man', z.B.

  • Abschnitt 1: Programme für Benutzer (unter /bin oder /usr/bin oder /usr/local/bin)

  • Abschnitt 4: Spezielle Dateien (Gerätedateien, siehe man 4 null)

  • Abschnitt 5: Dateiformate und Konventionen (z.B. Aufbau der Datei /etc/fstab: man 5 fstab)

  • Abschnitt 6: Spiele (z.B.: man 6 fiberlamp)

  • Abschnitt 8: Programme für root (unter /sbin oder /usr/sbin oder /usr/local/sbin)

TIPP für die Praxis: Option '-a' verwenden, um sich alle Abschnitte einer gegebenen man-Page anzeigen zu lassen

=> man -a mount
=> man -a crontab     (Hier werden nacheinander die Seiten der Abschnitte 1 und 5 geöffnet)

Eine schnelle Suche im Beschreibungstext des Pages ist mit

  • apropos <PATTERN>

  • man -k <PATTERN>

möglich. Hierbei wird aus 'NAME' bzw. 'BEZEICHNUNG' gesucht. Siehe auch whatis <KOMMANDO>.

Außerdem spielt hier auch das Kommando 'whereis' eine Rolle, es gibt mehrere Dinge aus:

tux@deb8-2:~$ whatis whereis
whereis (1)          - locate the binary, source, and manual page files for a command
tux@deb8-2:~$

Topic 103.2 - Textströme mit Filtern verarbeiten

⇒ Seite 100 ff

ZIEL: Ausfiltern von Zeichenströmen auf bestimmte, interessante Inhalt, dabei ist mehrzeilige Arbeitsweise möglich, wie es z.B.

  • join (join lines of two files on a common field)

  • paste (merge lines of files)

möglich machen.

Komplettes Ausgeben von Dateien

  • cat (catenate = verketten), Abarbeitung von oben nach unten

  • tac (= reverses cat), Abarbeitung von unten nach oben

Beispieldatei 1: vi textfile1

1        Birnen
2        Äpfel
3        Bananen
4        Erdbeeren

Beispieldatei 2: vi textfile2

cat textfile2
hellgrün
rot
gelb
dunkelgrün

Zeilen filtern

Nur eine gewisse Zahl von Zeilen ausgeben:

  • head (per Default die ersten 10 Zeilen ausgeben)

    • Wichtige Option: -n <NUMBERS> oder -<NUMBERS>

  • tail (per Default die letzten 10 Zeilen ausgeben)

    • Wichtige Optionen:

      • Zeilenzahl: -n <NUMBERS> oder -<NUMBERS>

      • Folge dem Inputstrom (Monitoring) -f pder --follow
        Bsp.: tail -f /var/log/messages

Im Praxistest:

tux@deb8-2:~$ head -2 textfile1 textfile2
==> textfile1 <==
1        Birnen
2        Äpfel

==> textfile2 <==
hellgrün
rot
tux@deb8-2:~$

AUFGABE: Lassen Sie sich nur die Zeilen 2 und 3 der Textdatei "textfile1" ausgeben, die insgesamt aus 4 Zeilen besteht.

  • Lösung 1: Nach unten bis einschließlich zur gewünschten Zeile gehen, dann von diesem ausgeschnittenen Bereich nach oben gehend den relevanten Rest stehen lassen:

    tux@deb8-2:~$ head -3 textfile1 | tail -2
    2        Äpfel
    3        Bananen
    tux@deb8-2:~$
  • Lösung 2: Von unten bis einschließlich zur gewünschten Zeile gehen, dann von diesem ausgeschnittenen Bereich von oben herab gehend den relevanten Rest stehen lassen

    tux@deb8-2:~$ tail -3 textfile1 | head -2
    2        Äpfel
    3        Bananen
    tux@deb8-2:~$

Zeilen nummerieren

  • nl dateiname (Leerzeilen werden per Default NICHT nummeriert)

  • cat -n dateiname

Pager (Textdateien seitenweise lesen)

  • more (Besitzt keine solchen Komfortfunktionen wie less z.B. beim Bildschirmauschnittsblättern)

  • less (= der Pager für man-Pages)

Motto: Less is more.

Tabulatorschritte in Leerzeichen umwandeln

Man kann mit expand/unexpand Tabulatorschritte in Leerzeichen umwandeln und umgekehrt.

=>   AUFGABE: Welches Tool macht was genau?
tux@deb8-2:~$ whatis  expand
expand (1)           - convert tabs to spaces

tux@deb8-2:~$ whatis  unexpand
unexpand (1)         - convert spaces to tabs

Topic 103.2 - Process text streams using filters

⇒ Seite 103 ff

Weitere Werkzeuge:

  • format text: 'fmt', Beispiel: Einen Text-Screenshot von virtueller (schwarzer) Konsole 1 formatieren

    root@deb8-2:~# cat /dev/vcs1 > tty1.out
    root@deb8-2:~#
    root@deb8-2:~# fmt -w 80 tty1.out
    
            Debian
    
                                                                                    GNU/Linux
                                                                                    8
                                                                                    deb8-2
                                                                                    tty1
                                                                                    deb8-2
                                                                                    login:
  • print (pre stage, = Druckvorstufe z.B. für 'lp'):

    • Einen Offset von 7 Zeichen hinzufügen: 'pr', z.B. pr -o 7 myfile.txt | lp

    • Mit '-h' kann man auch einen eigenen Header einfügen: pr -o 7 -h "Dienste und Portnummern" /etc/services | less

  • word count: 'wc', Beispiel: wc -l /etc/hosts, Optionen:

    • Lines: '-l' oder '--lines'

    • Words: '-w' oder '--words'

    • Characters: '-m' oder '--chars'

  • hexadecimal dump: 'hexdump', Beispiele:

    • Partittionstabelle ausgeben: hexdump /dev/sda | head -32 | tail -5

    • Die Datei /etc/hostname im Oktalformat ausgeben: hexdump -o /etc/hostname

  • sort characters: 'sort', Beispiele:

    • Verzeichnisgrößen berechnen ('-n' = numerisch): du -s /usr* | sort -n

    • Top Ten der großen Verzeichnisse ('-r' = reverse): du -s /usr/share/* | sort -nr | head

    • Bequemer, weil "human" readeable ('-h'): du -sh /usr/* | sort -h

    • Sortierte Ausgabe in selbe Datei wieder zurückschreiben ('-o' = output file): sort myfile.txt -o myfile.txt

      • ACHTUNG, so geht es nicht (DATENVERLUST!): sort myfile.txt > myfile.txt
        (Zuerst wird wegen der Umleitung ein Filehandle eingerichtet,
        dann die Datei geleert (mit ">>" würde append durchgeführt) und zum Schluss die leere Datei sortiert.)

    • Ignorieren des Case-Sensivität: Option '-i'

  • uniq (doppelte Zeilen entfernen): 'uniq', Beispiel: doppelte Dateien finden:

    • Im Experiment mit find, md5sum, sort und uniq führt dies schnell zu langen Zeilen, ein erster Versuch sieht so aus:

      find -type f -exec md5sum {} \; | sort | uniq
    • Eine praktikable, elegante Lösung ist dann schon komplexer, siehe

      find -not -empty -type f -printf "%-30s'\t\"%h/%f\"\n" | \
          sort -rn -t$'\t' | \
          uniq -w30 -D | \
          cut -f 2 -d $'\t' | \
          xargs md5sum | \
          sort | \
          uniq -w32 --all-repeated=separate
    • PRÜFUNGSHINWEIS: Das Kommando 'uniq' kann u.U. überflüssig werden, wenn 'sort -u' (sort-option 'uniq') verwendet wird.

      • splitting files: 'split', per Default splittet das Kommando Dateien in 1000 ZEILEN große Stücke auf, Beipiel:

        # Top Ten der größten Dateien unter /usr/bin:
        ls -lhS /usr/bin/
        
        # Die größte Datei jetzt aufsplitten (14 MB)
        split /usr/bin/syncthing
        
        # Zur Kontrolle die Größe der Einzelteile betrachten:
        du -sh x*
        
        # Jetzt die Teile wieder unter neuem Namen zusammensetzen:
        cat x* > syncthing.merged
  • cutter (Spaltenweises Auftrennen von maschinenlesbaren Dateien): 'cut',

    • Optionen:

      • Auftrennung nach Feldern (Spalten): '-f 1-3' (nur Felder 1 bis 3 ausgeben)

      • Angeben des Trenners (delimiter): '-d:' (Hier ist der Trenner ist ein (":"), per Default ist es ein Tabulator-Schritt)

      • Wegschneiden nach eine bestimmten Anzahl von Characters: '-c'

    • Beispiele:

      • Ausgeben aller Benutzernamen und deren User-IDs: cut -d: -f1,3 /etc/passwd

      • Herausfiltern des prozentualen Wertes der root-Partitionsauslastung: df / | tail -1 | cut -c 46-47

  • paste files (Dateiinhalte zeilenweise stumpf zu einer neuen, mehrspaltigen Datei zusammensetzen): 'paste', Beispiel:

    tux@deb8-2:~$ cat textfile1 textfile2
    1        Birnen
    2        Äpfel
    3        Bananen
    4        Erdbeeren
    hellgrün
    rot
    gelb
    dunkelgrün
    tux@deb8-2:~$
    
    tux@deb8-2:~$ paste textfile1 textfile2
    1        Birnen        hellgrün
    2        Äpfel        rot
    3        Bananen        gelb
    4        Erdbeeren        dunkelgrün
    tux@deb8-2:~$
  • joining files (Dateiinhalte zeilenweise unter Verwendung eines gemeinsamen Feldes als Verbindungskriterium zur einer neuen, mehrspaltigen Datei zusammensetzen): 'join', Beispiel:

    tux@deb8-2:~$ cat obst farbe
    1:Birnen
    2:Äpfel
    3:Bananen
    1:hellgrün
    2:dunkelgrün
    3:gelb
    tux@deb8-2:~$
    
    tux@deb8-2:~$ join -t: -j1 obst farbe
    1:Birnen:hellgrün
    2:Äpfel:dunkelgrün
    3:Bananen:gelb
    tux@deb8-2:~$
  • translation of characters, Kommado 'tr', (es handelt sich um eine einfache Form von "sed", das Tool kann immer nur eine gleiche Anzahl von Zeichen übersetzen):

    • Beispiele:

      • echo ABC | tr 'A-Z' 'a-z'

      • echo ABC | tr '[:upper:]' '[:lower:]'

      • Eine DOS-Datei in eine Unix-Datei umwandeln (Hintergrund: https://de.wikipedia.org/wiki/Zeilenumbruch):

        tux@deb8-2:~$ vi dosfile
        # Am Zeilenende immer ein STRG + v sowie STRG + m anhängen (Insert-Modus)^M
        Zeile 1^M
        Zeile 2^M
        
        # Dateityp prüfen
        tux@deb8-2:~$ file dosfile
        dosfile: ASCII text, with CRLF line terminators
        tux@deb8-2:~$
        
        # Zeilenumbruch umwandeln ('tr' kann man nicht Dateinamen übergeben!)
        cat dosfile | tr -d '\r' > unixfile
        tux@deb8-2:~$
        tux@deb8-2:~$ file unixfile
        unixfile: ASCII text
        tux@deb8-2:~$
  • stream editor: 'sed' (Mehr dazu unter Topic 103.7 - "Reguläre Ausdrücke")

Topic 103.3 - Perform basic file management

ZIEL: Neben grundlegenden Datei- und Verzeichnisoperationen lernen wir auch Kompressionswerkzeuge und Archivierungstool kennen und verstehen, sie einzusetzen.

Philosophie: 'Alles ist eine Datei.'

Kommandos für Dateioperationen

Kommando "ls"

Zweck: Auflisten von Verzeichnisinhalten und Dateieigenschaften

Hier gleich mal eine Grafik zur wichtigsten Option '-l' (long), die sehr viele Details liefert:

ls mit Option 'long'

Wichtige Optionen:

  • '-l' - Langes Ausgabeformat

  • '-i' - Inode-Nummer (Datei-Knotennummer)

  • '-s' - Size der belegten Blöcke

  • '-a' - all Files: auch die versteckten "hidden" Files anzeigen (ausblenden von Profiles-Dateien, die separat
    angesprochen werden müssen, sollen sie eine Aktion mit eingeschlossen werden)

  • '-h' - Dateigrößen menschengerecht (human readeable) in gut lesbare Einheiten umrechnen

  • '-S' - Nach der Größe der Datei sortieren

  • '-r' - Reverse (umgekehrte Sortierung)

  • '-R' - Rekursiv alle Unterverzeichnisse auflisten

  • '-d' - Directory-Eigenschaften betrachten, NICHT den Inhalt des Verzeichnisses, Dateijoker "*" entkräften für nichtrekursives Arbeiten:

ls -l /usr/share/doc/*ba*
  • '-t' Time sorted Output: Nach Änderungszeit (modification time) sortiert ausgeben

Kommando "cp"

ZIEL: Kopieren und evl. glechzeitig es umbenennen:

Es gibt zwei grundsätzliche Modi:

a) Kopiere eine oder mehrere Dateien in einen Zielordner: cp /etc/fstab /etc/hostname /etc/hosts /tmp, ein weiteres Beispiel:

HINWEIS: Wir verwenden hier das Kommando 'touch', das eigentlich ein Zeitstempelwerkzeug ist, um drei leere Dateien anzulegen.

touch a b c
mkdir d
cp a b c d
ls -l d/

b) Kopiere eine Datei auf eine andere, wobei sie ohne eine Sicherungskopie anzufertigen überschrieben wird, falls nicht der Schalter '-b' (backup) verwendet wird.

echo Hallo... > datei1.txt
cp -b /etc/hostname datei1.txt
cat datei1.txt datei1.txt~

AUFGABEN:

  1. Kopieren Sie in Ihr Verzeichnis '~/Dokumente' die Dateien '/etc/hosts.allow' und '/etc/hosts.deny' hinein.

    => cp  /etc/hosts.allow  /etc/hosts.deny  ~/Dokumente/
  2. Kopieren Sie in Ihr Verzeichnis '~/Dokumente' in das Verzeichnis '~/Downloads* hinein.

    => cp  -r   ~/Downloads/  ~/Dokumente/
  3. Kopieren Sie die Datei /etc/hosts unter Umbenennung zu 'IP-und-Hostnamen.txt' ins Verzeichnis '~/Dokumente'.

    => cp /etc/hosts  ~/Dokumente/IP-und-Hostnamen.txt

Bitte weitere Optionen in 'man cp' studieren, welche Optionen vereint der der Schalter '-a'?
Siehe https://wiki.ubuntuusers.de/cp/ https://wiki.ubuntuusers.de/cp/

  • '-R' - Rekursiv arbeiten

  • '--preserve=all' - Preserve all: Dateirechte, Zeitstempel usw. erhalten

  • '-d' - no Dereference SymLinks: belasse die Links beim Kopieren so wie sie sind, nicht die dahinter stehenden Dateien kopieren

Beispiel (als root auszuführen):

root@deb8-2:~# cp  -a  /var/lib/nfs  /root/var_lib_nfs
root@deb8-2:~# ls -ld /root/var_lib_nfs
drwxr-xr-x 1 statd nogroup 134 Jan 19 16:29 /root/var_lib_nfs

Kommando "mv"

Das Kommando bedeutet 'move' und macht den Unterschied zu 'cp' aus:

  • Es benennt eine Datei oder ein Verzeichnis um, wenn die Operation im selben Pfad geschieht.

  • Es verschiebt Objekte, wenn als Zielpfad ein anderes Verzeichnis angegeben wird.

ACHTUNG: Anderns als 'cp' kann 'mv' immer rekursiv arbeiten (um die Umlagerung im Dateibaum zu ermöglichen), außerdem bleiben dabei naturgemäß Dateirechte, Zeitstempel usw. erhalten.

Kommando "rm"

Mit 'remove' werden zuerst einmal nur Dateien gelöscht, will man Verzeichnisse löschen, muss rekursiv gearbeitet werden: Option '-r'

Aus Sicherheitsgründen sollte ein Alias eingerichtet werden, der versehentliches Löschen durch interaktives Rückfragen vermeiden hilft:

root@deb8-2:~# alias rm='/bin/rm -i'
root@deb8-2:~# cp -a /etc/ /root/etc_$(date +%F)
root@deb8-2:~#
root@deb8-2:~#
root@deb8-2:~# du -sh /etc/ /root/etc_2016-01-20/
12M        /etc/
12M        /root/etc_2016-01-20/
root@deb8-2:~#
root@deb8-2:~# rm -r /root/etc_2016-01-20/
/bin/rm: in Verzeichnis „/root/etc_2016-01-20/“ absteigen? j
/bin/rm: reguläre Datei „/root/etc_2016-01-20/fstab“ entfernen? j
/bin/rm: in Verzeichnis „/root/etc_2016-01-20/.java“ absteigen? j^C
root@deb8-2:~#

Wie kann dann aber ein schnelles Löschen erzwungen werden?

  1. Alias für einmalige Ausführung umgehen: Backslash voranstellen: \rm -r /root/etc_2016-01-20/

  2. Alias aus der Umgebung entfernen: unalias rm ; rm -r /root/etc_2016-01-20/

  3. Mit Hilfe der 'rm'-Option '-f' (force): rm-rf /etc/host

Kommandos für Verzeichnisoperationen

Kommandos 'mkdir' und 'rmdir'

Mit 'mkdir' können neue Verzeichnisse angelegt werden, komplette Strukturen nur mit der Option '-p' (parents)

mkdir -p ~/Briefe/Privat/Einkaufen/Lebensmittel/Gesunde

Sicheres Löschen von Verzeichnisstrukturen am besten mit 'rmdir' durchführen, das nur leere Ordner löschen kann; hier gibt es auch wieder '-p' (parents):

rmdir -p ~/Briefe/Privat/Einkaufen/Lebensmittel/Gesunde

Metapher: Von rechts solange zurückrollen, bis man auf einen Widerstand stößt: das kann eine versteckte Datei z.B. '.keep' oder auch ein leerer Ordner sein.

VORSICHT: Diese Art Aufräumaktionen NICHT mit der Systemwurzel durchführen!!

tux@deb8-2:~$ touch ~/Briefe/Privat/.keep
tux@deb8-2:~$ rmdir -p  ~/Briefe/Privat/Einkaufen/Lebensmittel/Gesunde
rmdir: konnte Verzeichnis „/home/tux/Briefe/Privat“ nicht entfernen: Das Verzeichnis ist nicht leer
tux@deb8-2:~$

Weitere wichtige Kommandos für Dateiarbeit:

  • 'touch' - Files "berühren", um den Zeitstempel zu ändern, wenn das File nicht existiert, wird es einfach erzeugt

    • FRAGE: Welchen der Zeitstempel kann 'touch' nicht ändern?

    • ANTWORT: Die 'Change Inode Time' (chown/chmod; find-Kürzel: -cmin/-ctime) zu ändern ist nicht direkt bzw. unabhängig möglich!

      • Modification Time (vi / nano, libreoffice; find-Kürzel: -mmin/-mtime): Aus der man-Page: '-a change only the access time'

      • Access Time (cat, more, less; find-Kürzel: -amin/-atime): Aus der man-Page: ' -m change only the modification time'

  • dd - disk dump: Files bestimmter Größe erzeugen, z.B. 100kB: dd if=/dev/zero of=myLittleFile.img bs=100k count=1

  • find - finden von Files aller Art, grundlegende Syntax find [PFADE] [PFADTIEFE] [DATEISYSTEM] [BEDINGUNGen…​] [AKTIONen…​]

    • Wichtige Optionen:

      • Case-Sensitiv: '-name <PATTERN>' (es arbeitet immer rekursiv, auch versteckte Dateien werden mit gefunden)

      • Ignore Case-Sensivity: '-iname <PATTERN>'

      • Dateityp-Suche: '-type <fdlsp>' (Typen: file, directory, symlink, socket, pipe)

      • Max. Verzeichnistiefe: '-maxdepth <ZAHL>', Beispiel: find / -maxdepth 3 -name resolv.conf

      • Einschränkung auf das lokale Dateisystem: '-xdev', Beispiel: find / -maxdepth 5 -xdev -name "bashrc"

      • Zeitstempel: siehe oben bei 'touch'

      • Besitzer von Files: '-user <USERNAME/ID>, '-uid <UID>

      • Leerzeichen duch Null-Zeichen für nachfolgende Ausführung via xargs ersetzen: '-print0'

        tux@deb8-2:~$ find Dokumente/2016-01-21/* -print0 | xargs -0  du -h
        4,0K        Dokumente/2016-01-21/dateimanagement-redirects-pipes.adoc
        0        Dokumente/2016-01-21/dateiname mit spaces.txt
        tux@deb8-2:~$
        
        ### Weitere Beispiele:
        # Alle Dateien, die in eben dieser Minute durch 'make install' nach /usr kopiert wurden,
        # ausgeben:
        find /usr -cmin 1
        
        # Ein Verzeichnis als Vergleichswert für Zeitstempelsuche heranziehen
        find -cnewer /home/tux/TimeStamp/ -type f -mmin -60

Wildcards für Dateinamen und -pfade (S. 117 f)

  • Stern ('*'): Bringt Übereinstimmung für eine beliebig lange Zeichenkette beliebiger Zeichen, auch kein Zeichen

  • Fragezeichen ('?'): Bringt Übereinstimmung für ein beliebiges Zeichen

  • In eckigen Klammen ('[abcxyz]'): Bringt Übereinstimmung für ein beliebiges Zeichen aus der hier angegebenen Menge bzw. des Bereiches
    Negation: Mit einem nach der öffnenden Klammer eingefügten Ausrufezeichen ('!') wird Umkehrung erreicht (ACHTUNG: Bei regexp ist dies ähnlich, aber mit einem anderen Zeichen verbunden: ('^') Zum Beispiel nicht die Dateien ausgeben, die entweder auf eine 1 oder eine 2 enden: ls -l textfile[!12]

Wichtige Kommandos für Archivierung

tar - Für Tapes geschaffenes Archivierungsprogramm:

  • Ohne Komprimierung: tar cf Dokumente.tar Dokumente/

  • Mit GnuTar zugleich komprimieren (Dies können alte Unixe nicht!): tar czf Dokumente.tar.gz Dokumente/

    • Hierbei bedeuten die Optionen: c = create, z = Packen mit gzip, f = filename of the archive

    • Weitere Optionen:

      • '-v' = verbose

      • '-C' = change directory (mkdir TMP ; tar xzvf Dokumente.tar.gz -C TMP/)

      • '-x' = eXtract

      • '-j' = Packen mit bzip2

      • '-J' = Packen mit xz

      • '-t' = table of content ausgeben, nicht entpacken

cpio (S. Seite 121, über STDIN / STDOUT kopieren): Einsatz beim rpm-Paketformat (rpm2cpio), es kennt drei Modi:

  1. Copy-IN: Schalter '-i' oder '--extract' (ins Dateisystem extrahieren)

    • Beispiel (im Verzeichnis /tmp): cpio -i < ~/textfiles.cpio

  2. Copy-OUT: Schalter '-o' oder '--create' (aus dem Dateisystem ins Archiv kopieren; = Erzeugung des Archives)

    • Beispiel: ls *.txt | cpio -o > textfiles.cpio

    • Dateityp feststellen: file textfiles.cpio (textfiles.cpio: cpio archive)

  3. Copy-TROUGH: Schalter '-d' oder '--pass-through' (Via Standardinput Daten aufnehmen und ins Dateisystem kopieren)

    • Beispiel "Benutzer manuell erzeugen" (auszugsweise, als root durchzuführen):

      # Heimatverzeichnis erzeugen
      mkdir /home/lisa
      
      # Vorlagen einkopieren (cp würde dot-files mit kopieren!)
      cd /etc/skel
      find | cpio -pdm /home/lisa

Wichtige Kommandos für Komprimierung

Anderns als bei den Werkzeugen 'tar' und 'cpio' werden die Daten hier lediglich komprimiert, nicht in ein Archiv überführt.

  • gzip - Entpacken: gunzip oder gzip -d

  • bzip2 - Entpacken: bunzip2 oder bzip -d

  • xz - Entpacken: unxz oder xz -d

Die typische Unix-Komprimierung läuft so, dass direkt mit der Originaldatei gearbeitet wird, die danach ein anderes Dateisuffix erhält und somit umbenannt wurde!

Am Beispiel von gzip:

tux@deb8-2:~$ cp /etc/services .
tux@deb8-2:~$
tux@deb8-2:~$ ls -lh services
-rw-r--r-- 1 tux tux 20K Jan 22 10:40 services
tux@deb8-2:~$
tux@deb8-2:~$ gzip -9 services
tux@deb8-2:~$
tux@deb8-2:~$ ls -lh services
ls: Zugriff auf services nicht möglich: Datei oder Verzeichnis nicht gefunden
tux@deb8-2:~$
tux@deb8-2:~$ ls -lh services*
-rw-r--r-- 1 tux tux 7,4K Jan 22 10:40 services.gz
tux@deb8-2:~$
tux@deb8-2:~$ file services.gz
services.gz: gzip compressed data, was "services", last modified: Fri Jan 22 10:40:29 2016, max compression,
 from Unix
tux@deb8-2:~$
tux@deb8-2:~$ ### Wollen wir den Inhalt der komprimierten Datei sehen, ohne sie zu entpacken, müssen wir
                  mit '-c' über STDOUT gehen:
tux@deb8-2:~$ gunzip -c services.gz | less

AUFGABE: Führen Sie die selben Operationen mit 'bzip2' und 'xz' durch.

Beispielhafte Lösungen:

cp /etc/services .
bzip2 services
cp /etc/services .
xz services
cp /etc/services .
xz -9 -c services >  services-level9.xz
xz -1 -c services >  services-level1.xz

# Zum besseren Vergleichen nur die tatsächliche Dateigröße in Byte und den Dateinamen ausgeben
ls -l services* | awk '{print$5, $9}'
19605 services
7229 services.bz2
7548 services.gz
7484 services-level1.xz
7156 services-level9.xz
7156 services.xz

Archivierung mit Komprimierung verbinden

Angenommen, es liegt nicht das moderne GNU-tar vor, sondern ein ein altes Unix-System, können die beiden Sparten trotzdem miteinander arbeiten:

a) Erzeugen eines komprimierten Archives:

# Der Bindestrich bedeutet in diesem Kontext: STDOUT für das Erzeugen des Archiv-files benutzen
tar cvf - foodir | gzip > foo.tar.gz

b) Entpacken des komprimierten Archives:

# Der Bindestrich bedeutet in diesem Kontext: STDIN für das Entpacken des Archiv-files benutzen
gunzip -c foo.tar.gz | tar xvf -
# oder
gunzip < foo.tar.gz | tar xvf -

Bitte den Schalter '-c' bei den Komprimierern gzip, bzip2 und xz wahrnehmen, durch ihn lassen sich erst die von tar stammenden Daten weiterverarbeiten.

Topic 103.4 - Use streams, pipes and redirects

Standard-Datenströme der Unix-Shells

Siehe S. 125 oben

  • Kanal STDIN: Dateideskriptor = 0, Umleitungs-Kürzel: "<", anhängende Arbeitsweise als Here-Dokument: "<<MARKE"

  • Kanal STDOUT: Dateideskriptor = 1, Umleitungs-Kürzel: ">", anhängende Arbeitsweise ">>"

  • Kanal STDERR: Dateideskriptor = 2, Umleitungs-Kürzel: "2>", anhängende Arbeitsweise "2>>"

ANMERKUNG: Den Dateidekriptor kann man weglassen, wenn das Kürzel eine eindeutige Interpretation durch die "Pfeilrichtung" zulässt, ansonsten muss die Ziffer angegeben werden. Bei STDERR muss sie immer mit notiert werden.

a) Zu Kanal STDIN:

Motto: Ein Kommando liest von der Tastatur:

tux@deb8-2:~$ wc -l


Hallo?
ABC...
Fertig?
5
tux@deb8-2:~$
tux@deb8-2:~$ #### Ja, durch Drücken von 'STRG + D' (End of File, EoF)

b) Zu Kanal STDOUT:

tux@deb8-2:~$ df -h /
Dateisystem    Größe Benutzt Verf. Verw% Eingehängt auf
/dev/sda5        28G    6,2G   21G   24% /
tux@deb8-2:~$

c) Zu Kanal STDERR (wird genauso wie STDOUT ins Terminal gesendet):

tux@deb8-2:~$ df -h /SERVER
df: „/SERVER“: Datei oder Verzeichnis nicht gefunden
tux@deb8-2:~$

Pipelines zum Weiterverarbeiten der Datenströme

Das Kürzel für Pipes ist lediglich ein einzelnes Bar-Zeichen ('|'), dabei wird die Ausgabe eines Kommandos immer zur Eingabe des nächsten (STDOUT wird zu STDIN):

=>    cmd1  |  cmd2  |  cmd3

Beispiel:

tux@deb8-2:~$ df -h / | tail -1
/dev/sda5        28G    6,2G   21G   24% /
tux@deb8-2:~$

Beim Durchreichen der Daten tritt jetzt allerdings ein Problem auf: Zwischenergenisse gehen verloren! Im Beispiel von oben ist uns ja der Header, also die folgende Zeile verlorengegangen:

Dateisystem    Größe Benutzt Verf. Verw% Eingehängt auf

Wie kann man nun darauf zrückgreifen: Es muss ein T-Stück (engl: 'tee') eingebaut werden:

tux@deb8-2:~$ df -h / | tee header+content.txt | tail -1
/dev/sda5        28G    6,2G   21G   24% /
tux@deb8-2:~$
tux@deb8-2:~$ cat header+content.txt
Dateisystem    Größe Benutzt Verf. Verw% Eingehängt auf
/dev/sda5        28G    6,2G   21G   24% /
tux@deb8-2:~$

Dort liest man auch über die für uns wichtige Option '-a' (append): "Mit -a wird an die angegebene Datei angehängt (anstatt eine neue leere Datei zu eröffnen)"

Umleitungen der Standardkanäle durchführen

Siehe oben bei der Erklärung der drei Standard-Ströme.

Es lassen sich Kanäle verbinden, daszu wird das Kaufmanns-Und eingesetzt:

Aus Prüfung B)
In bash, inserting 2>&1 after a command redirects
A. standard error to standard input.
B. standard input to standard error.
C. standard output to standard error.
D. standard error to standard output.
E. standard output to standard input.
Richtige Antwort: D

Hintergrund: Für typische Aufgaben wie das Kompilieren von Anwendungen soll jeglicher Output, auch Fehlermedlungen gespeichert werden:

make > my-important-file.log 2>&1
### Bash redirection

# stdout -> Datei umleiten
programm > Datei.txt

# stderr -> Datei umleiten
programm 2> Datei.txt

# stdout UND stderr -> Datei umleiten
programm &> Datei.txt

# stdout -> stderr
programm 1>&2

#stderr -> stdout
programm 2>&1

Ein Beispiel mit einer Datei, in der Klein- und Großschreibung wild gemischt sind. Es soll alles in Kleinbuchstaben umgewandelt werden:

tux@deb8-2:~$ tr '[:upper:]' '[:lower:]' < kontakte | nl
     1        müller
     2        meier
     3        schulze
tux@deb8-2:~$

Weitere Verarbeitungskürzel der bash

  • Kommandozeilen OHNE Prüfung des Exitcodes aneinanderreihen mit Hilfe dem Semikolon (';')

  • Kurztests auf Erfolg durchführen

    • Nur bei Erfolg weiterarbeiten (zwei Ampersand-Zeichen): '&&'

    • Nur bei Missrfolg weiterarbeiten (zwei Bar-Zeichen): '||'

Beispiele:

tux@deb8-2:~$ cat /etc/hostname && echo Alles OK.
deb8-2
Alles OK.
tux@deb8-2:~$
tux@deb8-2:~$ cat /etc/HOSTNAME && echo Alles OK.
cat: /etc/HOSTNAME: Datei oder Verzeichnis nicht gefunden
tux@deb8-2:~$
tux@deb8-2:~$ cat /etc/hostname || echo Wir gehen zu Plan über....
deb8-2
tux@deb8-2:~$
tux@deb8-2:~$ cat /etc/HOSTNAME || echo Wir gehen zu Plan über....
cat: /etc/HOSTNAME: Datei oder Verzeichnis nicht gefunden
Wir gehen zu Plan über....
tux@deb8-2:~$

Topic 103.5 - Create, monitor and kill processes

Siehe Seite 128 ff

Überwachen von Prozessen

Wichtige Werkzeuge sind unter anderem:

  • ps - Process Snapshots (ohne Option: Nur die Prozesse der aktuellen Shellumgebung werden angezeigt)

    • Optionen (Achtung: Bindestriche bedeuten "AT&T / Solaris-Syntax", keine Bindestriche dagegen heißt BSD-Syntax verwenden, die wir im folgenden verwenden):

      • a - Alle Prozesse ausgeben, auch die anderere Benutzer

      • u - User defined Format (ausführlich)

      • x - Nicht mit einer Shell verbundenen Daemons ebenfalls ausgeben (Kennzeichen in Spalte 'TTY': ('?'))

      • l - Long Listing, auch Prioritäts- und Nice-werte auflisten

      • -C <DIENST> - Die Prozesse, die ein bestimmter Dienst verursacht, auflisten, Bsp.: ps -C sshd

      • -U <USER> - Die Prozesse, die ein bestimmter Nutzer verursacht, auflisten

  • pstree - Prozess in Baumform ausgeben

    • Optionen:

      • -p - Prozess-IDs ausgeben

      • -n - Prozess-ID numerisch sortieren

  • top - Prozesse in einem sich selbst aktualisierenden Monitor präsentieren (top = die größten Ressourcenverbraucher zuerst)

    • Wichtige Ausgaben im Programmfenster:

      • Erste Zeile: Statistiken gemäß Kommando 'uptime'

      • Zweite und dritte Zeile: Statistiken über Prozesse und CPU-Auslastung

      • Vierte und fünfte Zeile: RAM-Auslastung gemäß Kommando 'free' anzeigen

      • Die weiteren Zeilen: Live-Monitor

    • Interaktive Bedienung des Programmes:

      • q - quit

      • 1 - alle Prozessoren anzeigen

      • u <USERNAME> - Nach einem Nutzer filtern

      • r - Renice von Prozessen durchführen (Nice-Wert nachträglich ändern)

      • k - Killen von Prozessen (PID und Signalnummer angeben)

    • Wichtige Optionen:

      • -i - Nur aktive Prozesse anzeigen

      • -d <TIME> - Delay-Zeit [s] angeben (Standard = 1s)

      • -q - Ausgaben in Echtzeit liefern

    • Praxisbeispiel: Ein Programm frisst so viel Ressourcen, dass das System langsam wird (Out of Memory-Killer ⇒ OOM-Killer)

      • Firefox mit laufenden Flash-Plugins

      • Den "Taskmanager" top starten: top

      • Die vorgeschlagene PID übernehmen oder anpassen, Taste 'k' (kill) drücken

      • Die vorgeschlagene Signalnummer (15) übernehmen oder anpassen, eine '9' macht ein Clean up des Programmes unmöglich (SIGKILL)!

      • Beobachten, ob der Systemzustand wieder in Ordnung ist

      • Beenden des Programmes 'q'

Arbeiten mit Signalen

Recherche-Aufgaben: Suchen Sie nach BIldern, die im Zusammenhang mit Unix/Linux und dem Prozesszyklus stehen (Lebenszyklus, fork(), suspend, running)
http://www2.htw-dresden.de/~fritzsch/BS/bs_script.html

Seite 133: Bitte die folgenden Signale lernen:

  • SIGHUP = 1, No Hangup, das bedeutet heute: Daemons sollen ihre Konfiguration neu einlesen

  • SIGINT = 2 (Via Tastatur: STRG + c), die Abarbeitung von Programmen abbrechen

  • SIGKILL = 9, die Abarbeitung eines Programmen gewaltsam beenden

  • SIGTERM = 15, die Abarbeitung von Programmen auf nomalen Wege terminieren

  • SIGCONT = 18, (Via Tastatur: STRG + q) die Abarbeitung eines Programmes nach einem Stop weiterarbeiten lassen

  • SIGSTOP = 19, (Via Tastatur: STRG + s) die Abarbeitung eines Programmes pausieren lassen (einen Stop einlegen)

AUFGABE: Bitte studieren Sie die Einführung von 'man 5 signal' sowie die Tabellen der Signalnummern. (5 min) * Default-Verhalten?

Prozesse können Signale abfangen, weil sie der Meinung sind, bestimmte Aufgaben zu Ende bringen zu müssen (Signal 15 ermöglich: Clean up).
Ein Signal allerdings kann nicht abgefangen werden: SIGKILL (Signal Nr. 9).

Übung: Starten Sie zum Testen ein ziemlich nutzloses Programm im Hintergrund: sleep 60 & (gern auch mehrmals)

tux@deb8-2:~$ sleep 60 &
[1] 4061
tux@deb8-2:~$
tux@deb8-2:~$ sleep 60 &
[2] 4062
tux@deb8-2:~$ sleep 60 &
[3] 4063
tux@deb8-2:~$
tux@deb8-2:~$ kill 4061
tux@deb8-2:~$
[1]   Beendet                 sleep 60
tux@deb8-2:~$
tux@deb8-2:~$ kill -9 4062
tux@deb8-2:~$
[2]-  Getötet                sleep 60
tux@deb8-2:~$

Weitere Tools zur Prozessmanipulation

  • killall - Via exakten Namen alle gleichnamigen Prozesse manipulieren (max. 64 Prozesse)

    tux@deb8-2:~$ sleep 60 &
    [1] 4519
    tux@deb8-2:~$ sleep 60 &
    [2] 4520
    tux@deb8-2:~$ sleep 60 &
    [3] 4521
    tux@deb8-2:~$ sleep 60 &
    [4] 4522
    tux@deb8-2:~$
    tux@deb8-2:~$
    tux@deb8-2:~$
    tux@deb8-2:~$ killall sleep
    [1]   Beendet                 sleep 60
    [2]   Beendet                 sleep 60
    [3]-  Beendet                 sleep 60
    [4]+  Beendet                 sleep 60
    tux@deb8-2:~$
  • pgrep - Eine Prozesssuche gestaltet sich viel schneller als mit ps aux | grep <PATTERN>.)

  • pkill - Vorsicht hier wird mit einem Pattern gearbeitet, es kann u.U. zu viel treffen!

  • xkill - Grafische Anwendungen mit einem einfachen Linksklick gewaltsam beenden
    (Aus der man-Page: "This program is very dangerous, but is useful for aborting programs that have displayed undesired windows on a user’s screen.")

  • Weitere Monitoring-Tools:

    • htop (Debian: "Htop ist ein ncurses-basierter Prozessbetrachter ähnlich wie top, jedoch ermöglicht er Ihnen die Liste vertikal und horizontal zu durchlaufen")

    • dstat (Debian: "Vielseitiges Ressourcenstatistikwerkzeug. Dstat ist ein vielseitiger Ersatz für vmstat, iostat und ifstat.)

    • monitorix (Webbasiertes, grafischen Auswertungstool (CGI-basiert), siehe http://www.monitorix.org/screenshots.html)

Tipp: Beenden verschiedenster Apps:

  • STRG + c (Signal 2)

  • STRG + d (done, End of File)

  • ESC (alsamixer)

  • q

  • quit

  • exit

Jobverwaltung der bash

Motivation: aus einer Shell-Sitzung lassen sich viele Programme gleichzeitig starten und verwalten (Komfort).

Wichtige Kürzel für den bash-Mechanismus:

  • & Ein einzelnes Ampersand, was man dem Kommandoaufruf mitgibt, startet das Programm im Hintergrund und führt es aus ('ding' ist ein Englisch/Deutsch-Dictionary, es muss nachinstalliert werden), ⇒ synchrone Abarbeitung, der Shellprompt wird frei gemacht

    tux@deb8-2:~$ ding &
    [1] 4663
    tux@deb8-2:~$
  • fg - foreground: Ein im Hintergrund laufendes Programm nach vorn holen, so dass es mit Tastenkombinationen manupuliert werden kann

  • bg - backgroud: Ein mit 'STRG + z' suspendiertes Programm im Hintergrund fortfahren lassen (so als ob man ein '%' angehängt hätte)

    tux@deb8-2:~$ ding
    ^Z
    [1]+  Angehalten              ding
    tux@deb8-2:~$
    tux@deb8-2:~$ jobs
    [1]+  Angehalten              ding
    tux@deb8-2:~$
    tux@deb8-2:~$ bg
    [1]+ ding &
    tux@deb8-2:~$
    tux@deb8-2:~$
    tux@deb8-2:~$ jobs
    [1]+  Läuft                  ding &
    tux@deb8-2:~$
  • jobs - Jobs auflisten

  • kill <%PID> - Prozesse über ihre Job-Nummer manipulieren

Beispiel: Ein Programm (bc = basic calculator) manuell in den HIntergrund suspendieren und aus dem Vordergrund heraus normal beenden:

tux@deb8-2:~$ bc -l
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.

3/1.5
2.00000000000000000000

^Z
[1]+  Angehalten              bc -l
tux@deb8-2:~$ killall bc
tux@deb8-2:~$ killall bc
tux@deb8-2:~$ killall bc              ### Kein Erfolg: Der Prozess müsste hier mit '-9' gekillt werden!
tux@deb8-2:~$
tux@deb8-2:~$ jobs
[1]+  Angehalten              bc -l
tux@deb8-2:~$
tux@deb8-2:~$ kill -15 %1             ### So gelingt ein sanftes Beenden

[1]+  Angehalten              bc -l
tux@deb8-2:~$
[1]+  Beendet                 bc -l
tux@deb8-2:~$

Topic 103.6 - Modify process execution priorities

Siehe Seite 140

Hier spielen für LPI zwei Kommandos eine Rolle:

  • nice (voranzustellendes Kommando) - Einen anderen Freundlichkeitswert beim Starten eines Kommandos setzen, per Default wird der positive Wert 10 benutzt)

  • renice (im nachhinein auszuführen, PID erforderlich) - Einen anderen Freundlichkeitswert im nachhinein, per Default wird der positive Wert 10 benutzt)

Darüber hinaus gibt es speziell für Datenträgeroperationen (kopieren, Backups anfertigen) das Kommando: 'ionice'

Wie funktioniert das Ganze?

  • nice-Werte sind nur Empfehlungen, der Kernel kann sie überstimmen (Bitte Spalte PRI bei 'ps l' beachten: Dies legt allein der Kernel fest!)

  • nice-Werte verhalten sich zu Prioritäten umgekeht proportional: Hoher nice-Wert = geringe Priorität und umgedreht.

  • Bereich für nice: -20 bis +19

    • Benutzer 'root': Er darf wie immer alles, also auch in den negativen Bereich gehen

    • Normale Benutzer: Nur positive Werte sind erlaubt.

Ein paar Beispiele:

tux@deb8-2:~$ nice sleep 120 &
[1] 7346
tux@deb8-2:~$
tux@deb8-2:~$ ps l
F   UID   PID  PPID PRI  NI    VSZ   RSS WCHAN  STAT TTY        TIME COMMAND
0  1000  1423  1418  20   0  24276   676 -      Ss+  pts/0      0:00 bash
0  1000  2633  1418  20   0  23920   416 -      Ss   pts/2      0:00 bash
0  1000  3312  1418  20   0  23960  4388 -      Ss   pts/1      0:00 bash
0  1000  4053  1418  20   0  23876   220 -      Ss+  pts/4      0:00 bash
0  1000  4338  1418  20   0  23936   352 -      Ss+  pts/5      0:00 bash
0  1000  6751  6748  20   0  23840  5736 -      Ss+  pts/7      0:00 -bash
1  1000  6801     1  20   0  24372  2336 -      S    pts/7      0:00 /usr/bin/dbus-launch --autolaunch ...
0  1000  7346  3312  30  10   5808   632 -      SN   pts/1      0:00 sleep 120
0  1000  7347  3312  20   0  10688  2092 -      R+   pts/1      0:00 ps l
tux@deb8-2:~$
tux@deb8-2:~$
tux@deb8-2:~$ renice -n 15 7346
7346 (Prozesskennung) alte Priorität 10, neue Priorität 15
tux@deb8-2:~$
tux@deb8-2:~$ ps l
F   UID   PID  PPID PRI  NI    VSZ   RSS WCHAN  STAT TTY        TIME COMMAND
0  1000  1423  1418  20   0  24276   676 -      Ss+  pts/0      0:00 bash
0  1000  2633  1418  20   0  23920   416 -      Ss   pts/2      0:00 bash
0  1000  3312  1418  20   0  23960  4388 -      Ss   pts/1      0:00 bash
0  1000  4053  1418  20   0  23876   220 -      Ss+  pts/4      0:00 bash
0  1000  4338  1418  20   0  23936   352 -      Ss+  pts/5      0:00 bash
0  1000  6751  6748  20   0  23840  5736 -      Ss+  pts/7      0:00 -bash
1  1000  6801     1  20   0  24372  2336 -      S    pts/7      0:00 /usr/bin/dbus-launch --autolaunch ...
0  1000  7346  3312  35  15   5808   632 -      SN   pts/1      0:00 sleep 120
0  1000  7349  3312  20   0  10688  2096 -      R+   pts/1      0:00 ps l
tux@deb8-2:~$
tux@deb8-2:~$ nice --20 sleep 120 &
[1] 7356
tux@deb8-2:~$ nice: die Priorität kann nicht gesetzt werden: Keine Berechtigung

tux@deb8-2:~$
tux@deb8-2:~$
tux@deb8-2:~$ nice -+19 sleep 120 &
[2] 7357
tux@deb8-2:~$
tux@deb8-2:~$ ps l
F   UID   PID  PPID PRI  NI    VSZ   RSS WCHAN  STAT TTY        TIME COMMAND
0  1000  1423  1418  20   0  24276   676 -      Ss+  pts/0      0:00 bash
0  1000  2633  1418  20   0  23920   416 -      Ss   pts/2      0:00 bash
0  1000  3312  1418  20   0  23960  4388 -      Ss   pts/1      0:00 bash
0  1000  4053  1418  20   0  23876   220 -      Ss+  pts/4      0:00 bash
0  1000  4338  1418  20   0  23936   352 -      Ss+  pts/5      0:00 bash
0  1000  6751  6748  20   0  23840  5736 -      Ss+  pts/7      0:00 -bash
1  1000  6801     1  20   0  24372  2336 -      S    pts/7      0:00 /usr/bin/dbus-launch --autolaunch ...
0  1000  7356  3312  20   0   5808   688 -      S    pts/1      0:00 sleep 120
0  1000  7357  3312  39  19   5808   672 -      SN   pts/1      0:00 sleep 120
0  1000  7358  3312  20   0  10688  2088 -      R+   pts/1      0:00 ps l
tux@deb8-2:~$
[1]-  Fertig                  nice --20 sleep 120
[2]+  Fertig                  nice -+19 sleep 120
tux@deb8-2:~$

Praktische Anwendungsfälle:

a) root möchte ressourcenschonend den Suchindex von 'locate' erneuern:

=> nice -19 updatedb &

b) tux möchte ressourcenschonend eine find-Suche für eigenen Bedarf durchführen:

=> nice -n +19 find 2> /dev/null > allMyFiles.txt

c) root will beim Erstellen von GnuPGP-Schlüsseln mehr Dampf geben (für duplicity-Backups):

=> nice --19 gpg --gen-key

Optionen und Aufrufmöglichkeiten:

Dies alles ist als Benutzer möglich:

tux@deb8-2:~$ nice -+13 sleep 2
tux@deb8-2:~$
tux@deb8-2:~$ nice -n+13 sleep 2
tux@deb8-2:~$ nice -n13 sleep 2
tux@deb8-2:~$ nice -n 13 sleep 2
tux@deb8-2:~$ nice -n +13 sleep 2
tux@deb8-2:~$

Das Folgende ergibt allerdings NEGATIVE Werte:

tux@deb8-2:~$ nice -n-13 sleep 2
nice: die Priorität kann nicht gesetzt werden: Keine Berechtigung
tux@deb8-2:~$
tux@deb8-2:~$ nice --13 sleep 2
nice: die Priorität kann nicht gesetzt werden: Keine Berechtigung
tux@deb8-2:~$

Bei 'renice' gibt es nicht ganz so viele Möglichkeiten, die Kürzel mit Minus/Plus ('-+') oder Minus/Minus ('--') funktionieren nicht: wir brauchen also die Option '-n', außerdem muss ein Leerzeichen zwischen '-n' und dem Wert stehen.

tux@deb8-2:~$ renice 19 7464
7464 (Prozesskennung) alte Priorität 0, neue Priorität 19
tux@deb8-2:~$
tux@deb8-2:~$ renice -19 7464
renice: Priorität für 7464 konnte nicht gesetzt werden (Prozesskennung): Keine Berechtigung
tux@deb8-2:~$
tux@deb8-2:~$ renice -n +19 7546
7546 (Prozesskennung) alte Priorität 0, neue Priorität 19
tux@deb8-2:~$

Topic 103.7 - Search text files using regular expressions

Siehe Seite 143 ff

Es handelt sich hierbei um eine in vielen Kommandos nutzbare Filtersprache (u.a. in Perl).

Welche Tools können damit originär umgehen?

  • grep (kein logisch ODER)

  • egrep (oder grep -E, = extended grep, beherrscht u.a. logisch ODER)

  • sed (stream editor)

  • vim

ACHTUNG: Das Tool 'fgrep' (oder grep -F) kann NICHT mit regulären Ausdrücken (das "f" bedeutet 'fixed' Strings), z.B. wenn man vermeiden möchte, dass der Punkt als "ein beliebiges Zeichen" interpretiert wird:

Beispiel: Der Punkt ist hier ein normales Zeichen:

root@deb8-2:~# find /boot/ | fgrep .cfg
/boot/grub/grub.cfg
root@deb8-2:~#

Gegenprobe, ob 'fgrep' wirklich nichts mit diesen regulären Ausdrücken anfangen kann:

### grep kann es:
root@deb8-2:~# grep -v ^# /etc/hosts
127.0.0.1        localhost
127.0.1.1        deb8-2.comcave.site        deb8-2

::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
10.22.15.119 c7
root@deb8-2:~#

### fgrep kann den Kommentar nicht ausblenden
root@deb8-2:~# fgrep -v ^# /etc/hosts
127.0.0.1        localhost
127.0.1.1        deb8-2.comcave.site        deb8-2

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
10.22.15.119 c7
root@deb8-2:~#

Wollen wir alternativ z.B. Car oder Auto in einer Datei finden, muss für diese logisch-ODER-Verknüpfung das 'Extended grep' herangezogen werden:

root@deb8-2:~# cat > textdatei.txt <<EOF
Ein Car ist ein Mobil,
das wir auch Auto nennen.
Fahrradfahren ist freilich umweltfreundlicher.
EOF
root@deb8-2:~# grep -E -i 'car|auto' textdatei2.txt
Ein Car ist ein Mobil,
das wir auch Auto nennen.
root@deb8-2:~#

Gibt es auch logisch-UND? Ja, hierfür brauchen wir zwei 'grep'-Zeilen via Pipe: Zuerst filtern wir z.B. alle Gerätedateien aus der /etc/fstab heraus, danach folgt ein weiterer Filter, der nur ext-Dateisysteme berücksichtigt:

root@deb8-2:~# grep '^/dev' /etc/fstab | fgrep ext
/dev/store01/www    /srv/www     ext3     defaults     0      2
root@deb8-2:~#

Aufgabenstellung:

  • Schneiden Sie alle Kommentar- und Leerzeilen aus der Datei /etc/hosts weg, so dass nur der wichtige Rest stehenbleibt:

    root@deb8-2:~# grep -v '^#' /etc/hosts | grep -v '^$'
    127.0.0.1        localhost
    127.0.1.1        deb8-2.comcave.site        deb8-2
    ::1     localhost ip6-localhost ip6-loopback
    ff02::1 ip6-allnodes
    ff02::2 ip6-allrouters
    10.22.15.119 c7
    root@deb8-2:~#
    root@deb8-2:~#

    Die Option '-v' kann entfallen, wenn die Negation mit einem Metazeichen durchgeführt wird:

    => grep ^[^#] /etc/hosts | grep -v ^$
  • Ein bestimmtes Wort finden: grep -i '\<car\>' textdatei.txt

Weitere reguläre Ausdrücke sind (Auszug von Seite 144 f):

  • Ein einzelner Punkt: ('.') - ersetzt EIN beliebiges Zeichen.

  • Ein Stern ('*') - Wiederholungsfaktor: Das davor stehende Zeichen beliebig oft

Somit lässt sich der gewöhnliche Dateijoker ('*') auf diese Art als regulärer Ausdrück realisieren: ('.*')

Wichtige Optionen:

  • -i - Ignoriere Groß- und Kleinschreibung

  • -v - inVertiere die Ergebnisse (negieren)

  • -r - Rekursiv arbeiten (Verzeichnisse samt Inhalt durchsuchen)

  • -E - Extended Arbeitsweise aktivieren (= egrep)

  • -F - Fixed-Strings-Arbeitsweise aktivieren (= fgrep)

  • -c - Counting: Zählt nur die Übereinstimmungen (gibt nur eine Zahl aus)

  • -n - Number of Line: Die betreffende Zeilennummer mit ausgeben

  • -l - Liste nur die Dateinamen auf, nicht den gefundenen Inhalt

  • -H - Liste die Dateinamen und den gefundenen Inhalt auf, ideal für eine kleine Suchmaschine:

    find /etc -type f -exec grep -iH --color linus {} \;

Der streaming Editor sed

Sed kann tatsächlich Dateien editieren, obwohl er sie nicht direkt wie 'vim' bearbeiten kann. Sein Name bedeutet: "Stream Editor":

  • Typisches Verhalten: Arbeiten im Datenstrom (Pipes)

  • Direkt eine Datei editieren: Option '-i' bzw. '--in-place'

Seine Stärke liegt im Suchen und Ersetzen im Datenstrom.

Allgemeine Syntax: sed 'BEFEHL' datei

Allgemeine Syntax für das Suchen und Ersetzen: sed 's/ALT/NEU/[g]' datei

Dabei bitte beachten:

  • Das kleine 's' steht für "substitute", damit wird der Vorgang eingeleitet

  • Die Zeichenkette 'ALT' soll on the fly durch 'NEU' ersetzt werden

  • Das optionale kleine 'g' steht für "global auf der Zeile agieren", was bedeutet, dass ein Mehrfachvorkommen auf der Zeile beachtet wird

Beispiele:

  • echo "Ich heiße Bob, mein Bobschlitten ist Bobbig." | sed 's/Bob/bob/'
    ⇒ ERGEBNIS: 'Ich heiße bob, mein Bobschlitten ist Bobbig.'

  • echo "Ich heiße Bob, mein Bobschlitten ist Bobbig." | sed 's/Bob/bob/g'
    ⇒ ERGEBNIS: 'Ich heiße bob, mein bobschlitten ist bobbig.'

  • echo BOB > bob.txt ; sed -i 's/BOB/bob/g' bob.txt

  • Ein sehr experimentelles Beispiel:

    tux@deb8-2:~$ echo ALT, ALT, ALT | sed 's/ALT/NEU/'
    NEU, ALT, ALT
    tux@deb8-2:~$
    tux@deb8-2:~$ echo ALT, ALT, ALT | sed 's/ALT/NEU/g'
    NEU, NEU, NEU
    tux@deb8-2:~$

Topic 103.8 - Perform basic file editing operations using vi

Siehe Seite 152 ff

Es gibt drei Modi:

  • COMMAND (ESC)

  • INSERT (i, o, a, A)

  • EXECUTE (:wq / :w / ZZ / :q! / :wq! / :e datei)

Navigation:

  • Ersatz der Cursortasten: h, j, k, l

  • Einen Bildschirmausschnitt nach unten (forward) blättern: STRG + f

  • Einen Bildschirmausschnitt nach unten (backward) blättern: STRG + b

Ganze Zeilen bearbeiten

  • dd - (delete) - eine ganze Zeile in den Löschpuffer (= Ausschneiden)

  • yy - (yank) - eine ganze Zeile in den Kopierpuffer legen

  • p - (paste) - Pufferinhalt eine Zeile darunter einfügen

  • HINWEIS: Dabei können den Befehlen ein Zahl für den Wiederholungsfaktor vorangestellt werden