Tag Archives: grep

grep, ack, find, locate, sed, diff, wc …

An dieser Stelle wollte ich einmal notieren wie ich in der täglichen Arbeit mit z.B. “grep” oder “find” etc. umgehe, um möglichst schnell in Verzeichnissen und Dateien zu suchen oder Text zu ersetzten.

Ich werde hier nicht alle Möglichkeiten der entsprechenden Befehle nennen können, daher beschränke ich mich auf das, was ich wirklich verwende. Falls du dich weiter in der Thematik einlesen möchtest, empfehle ich gerne den “man”-Befehl oder wie andere es ausdrücken RTFM!

Falls dir die Begriffe tail, cat, less nicht viel sagen, dann klick hier!!!

 

grep: 

global regular expression print -> durchsucht Dateien und Verzeichnisse via RegEx bzw. nach Strings

Kurzform Langform Beschreibung
-H
--with-filename
gibt den Dateinamen vor jedem Treffer aus.
-i
--ignore-case
unterscheide nicht zwischen Groß- und Kleinschreibung.
-n
--line-number
gibt die Zeilennummer vor jedem Treffer aus.
-R
-r
--recursive
liest alle Dateien unter jedem Verzeichnis rekursiv.
-v
--invert-match
Invertiert die Suche und liefert alle Zeilen die nicht auf das gesuchte Muster passen.

z.B.:

grep -rHn test ~/php/

-> sucht im Verzeichnis “php”, welches sich wiederum im Home-Verzeichnis [~] befindet nach dem String “test”

PS: hier der selbe Befehl, jedoch eingeschränkt auf php-Dateien

grep -Hn test ~/php/**/*.php

Info: wenn man “git” im Einsatz hat, sollte man “git grep” verwenden ;)

 

ack:

Ack hat die selbe Aufgabe wie “grep” ist jedoch auf Entwickler zugeschnitten, so sucht “ack” im Standardmäßig rekursiv, ignoriert Binärdaten und Verzeichnisse von Versionkontrollsystemen (.svn, .git, etc.)

PS: unter Debian / Ubuntu findet man das entsprechende Paket unter “ack-grep”

 

find:

ist bei der Suche nach Dateien behilflich (“Alles ist eine Datei”)

Suchkriterien für find
Kriterium Beschreibung
-name Datei
Es wird nach Dateien mit dem Namen “Datei” gesucht. Sollen bei der Suche Platzhalter Verwendung finden, so muss der ganze Ausdruck in Anführungszeichen gestellt werden, zum Beispiel

-name "*.txt"
-iname Datei
Es wird nach Dateien mit dem Namen “Datei” – ohne Beachtung der Groß und Kleinschreibung – gesucht.
-type f
Es wird nur nach regulären Dateien gesucht.
-type d
Es wird nur nach Verzeichnissen gesucht.
find -size +10M -20M -exec ls -lah {} \;

-> sucht alle Dateien welche eine Dateigröße zwischen 10 – 20 MB haben und zeigt diese an

WARNING: der “exec”-Parameter kann auch für jeden anderen Befehl auf die Ergebnismenge von “find” ausführen, dabei sollte man jedoch bei dem “rm”-Befehl besonders vorsichtig sein. Und ggf. kann man sich safe-rm anschauen. ;)

PS: hier sind noch ein paar Beispiel

 

locate:

“sudo updatedb” nicht vergessen und schon kann man sehr schnell nach Dateien suchen, da die Dateien nicht im Filesystem, sondern in einer Datenbank (updatedb) gesucht werden.

z.B.:

locate Download | grep home

 

sed:

Es handelt sich hier um einen “nicht-interaktiver Texteditor” was eigentlich nur bedeutet, dass man damit String verarbeite kann. Zum Bespiel kann man ein bestimmtes Wort in einer Datei durch ein anderes ersetzten.

https://github.com/voku/dotfiles/blob/master/.functions

# WARNING -> replace: changes multiple files at once
replace()
{
  if [ $3 ]; then
    find $1 -type f -exec sed -i 's/$2/$3/g' {} \;
  else
    echo "Missing argument"
  fi
}
replace *.php alt neu

-> dieser Befehl such im aktuellen (+ Unterverzeichnisse) nach Dateien, welche auf “.php” enden und ersetzt darin “alt” gegen “neu”

PS: hier findet man ein paar nützliche Beispiele

Dabei ist besonders praktisch, dass man diese Funktionalität auch im “vim” verwenden kann indem man z.B. folgendes eingibt …

 :%s/alt/neu/g

 

diff:

Wie der Name schon vermuten lässt, kann man hiermit Dateien vergleichen. z.B.:

diff -u --ignore-all-space -r old/ new/

-> vergleicht alle Dateien rekursiv (-r) vom Verzeichnis “old/” und “new/” und ignoriert dabei Änderungen vom Leerräumen z.B. Leerzeichen oder Zeilenumbrüche (\r <-> \r\n)

Info: wenn man “git” im Einsatz hat, sollte man “git diff” verwenden ;)

 

wc:

word count kann Wörtern, Zeichen und Bytes (man ahnt es bereits) zählen. z.B.:

cat /proc/cpuinfo | grep processor | wc -l

-> zählt die Anzahl der CPU-Kerne

 

Quellen:
http://beyondgrep.com/ – ack
http://wiki.ubuntuusers.de/grep
http://wiki.ubuntuusers.de/find
http://wiki.ubuntuusers.de/locate
http://wiki.ubuntuusers.de/wc
http://suckup.de/linux/find-linux/
http://suckup.de/linux/streameditor-sed/

top + 1

Linux-Server analysieren

Dieser Blog-Post ist als Antwort auf die Frage “Nun würde mich mal interessieren, welche Tools euch zum Administrieren eines Linux Servers helfen und speziell auch welchen Taskmanager ihr verwendet.”, aus dem folgendem Blog gedacht. -> infoblog.li/besserer-taskmanager-fuer-den-linux-server-htop/

 

1.) Überblick verschaffen

Wenn man nicht genau weiß, wo das Problem liegt, muss man sich erst-einmal einen groben Überblick über die Situation verschaffen, dabei helfen die folgenden Befehle:

 

1.1) top – CPU- und Arbeitsspeicher-Auslastung analysieren

top

Es folgen einige wichtige Tastenkürzel:

1 -> zeigt die Auslastung der einzelnen CPUs an
b / B -> hebt die aktiven Prozesse hervor
z -> wie “b oder B” nur mit Farbe ;-)
i -> zeigt nur aktive Prozesse an
M -> zeigt die Prozesse sortiert nach dem Speicherverbrauch an
P -> zeigt die Prozesse sortiert nach der CPU-Last an
d -> gibt die Aktualisierungszeit an
k -> kill – tötet einen Prozess

(alternativ kann man sich auch mal “htop” anschauen)

 

1.2) df / du – Festplattenverbrauch analysieren

df -h

-h -> auch für Menschen lesbar (–human-readable)

df -h
df -h

 

Wenn wir den Speicherverbrauch nun weiter analysieren müssen, weil z.B. ein Verzeichnis unter /var zu groß ist, können wir dies mit “du” machen.

du -h | grep "^[0-9,]*[MG]" | sort -hr | less

 

Erklärung: “du” gibt die Größe von Dateien und Verzeichnissen aus “-h” zeigt dies leserlich an, “|” der Pipe leitet die Ausgabe weiter, “grep” ist universal einsetzbar, um etwas (Dateien / Ausgaben…) zu durchsuchen und wir suchen alle Zeilen, in denen “^” am Anfang eine Zahl  “0 1 2 3 4 5 6 7 8 9″ oder / und “,” in beliebiger Häufigkeit “*” gefolgt von einem großen “M” oder einem “G”. Diese Ausgabe wird per Pipe “|” an “sort” weitergegeben, wo diese Ausgabe nach sortiert wird und “|” schließlich mit “less” angezeigt wird. (mit q kann man less wieder beenden) Wer mehr über Reguläre Ausdrücken lernen möchte, kann sich dies hier antun ;-) -> http://linuxwiki.de/

Wer will kann dich solche “Funktionen” einfach in die .bashrc eintragen…

alias du_suckup='du -h | grep "^[0-9,]*[MG]" | sort -hr | less'

 

1.3) iotop – Festplattenauslastung  analysieren

iotop

Der Befehl “iotop” kann die aktuellen I/O Transferraten für die laufenden Prozesse/Threads anzeigen und greift dazu direkt auf die Informationen vom Kernel zu ( >= v2.6.20 ).

Es folgen wieder einige wichtige Tastenkürzel:

Pfeiltasten – link & rechte -> ändern die Sortierung der Ausgabe, je nach Kategorie
r -> dreht die Sortierung um (reverse)
o -> Zeigt nur noch Prozesse/Threads an, welche auch I/O-Last produzieren
p-> zeigt nur noch Prozesse an (keine Threads )
a -> zeigt nicht mehr die Last in Sekunden an, sondern addiert die I/O fortlaufen (solange iotop läuft)

1.4) lsof – Beziehung zwischen Dateien & Prozessen analysieren

Der Befehl “lsof” kann eingesetzt werden, um z.B. zu analysieren, welcher Prozess oder Anwender momentan eine bestimmte Datei verwendet oder auch welcher User, welchen Port offen hält + die dazugehörige PID (ProzessID)…

lsof -a -i -u www-data

 

lsof - Beispiel
lsof – Beispiel

 

Wer mehr zu dem Thema erfahren möchte, kann in einen alten Blog-Beitrag weiter lesen -> suckup.de/blog/2010/02/22/lsof-list-open-files


2.) Prozesse analysieren

Hier verweise ich einfach mal auf zwei alte Blog-Beiträge.:

2.1) der Befehl “ps”, um bestimmte Prozesse aufzuspüren -> suckup.de/blog/2010/09/14/shell-ps-prozessstatus

2.2) und noch einige Programm, um den verbrauchten Arbeitsspeicher zu analysieren -> suckup.de/blog/2010/02/08/speicherverbrauch-anzeigen-lassen

 

3.) Hardware analysieren

Auch hier verweise ich auf einen alten Beitrag.:

3.1) hier noch eine Sammlung von Befehlen mit denen man z.B. die Festplatte auf Fehler prüfen kann ->  http://suckup.de/blog/2010/02/08/systeminfos-anzeigen-lassen/

 

4.) Netzwerk analysieren

Und auch hier verweise ich auf ein paar alte Beiträge.:

4.1) mit “TCPdump” kannst du den Netztraffik analysieren (sniffen) ähnlich wie Wireshark, nur auf der Konsole. :-) -> suckup.de/blog/2010/08/02/tcpdump-howto

4.2) offene Ports analysieren mit “nmap” + “fuser” -> suckup.de/blog/2010/03/28/offene-ports-analysieren

 

weitere Schritte

Mit Hilfe dieser Befehl sollte man einige Problem bereits eingrenzen können, ich würde parallel unter /var/log/ nachschauen, ob irgendetwas auffälliges in den Logfiles steht …

ls -altr /var/log/

-> Dateien rekursiv nach ihrer letzten Änderung anzeigen (neuste Datei steht nun unten)

tail -f test.log

-> das Logfile wird nun kontinuierlich mit-gelesen, so dass man neu auftretende Fehler bemerkt

Konsolen-Logo

lynx automatisieren

Bei einigen W-LANs muss man sich vorher per Browser auf einer Authentifizierungsseite einloggen, um dies zu umgehen habe ich einfach den Login-Vorgang mit lynx aufgezeichnet und dies in ein Skript verpackt.


# mit lynx die Tastatur Eingaben aufzeichnen
lynx -cmd_log wlan.log http://www.google.de/
# und diese als "Makro" wieder ausführen
lynx -cmd_script=wlan.log http://www.google.de/


#!/bin/bash

TERM="xterm"; export TERM  
export PATH="/sbin:/usr/sbin:/bin:/usr/bin:$PATH"

sleep 30  

# W-Lan Gateyway IP herausfinden ->
# Gateway-IPs | jedoch nicht eth | bei der Ausgabe muss vone 0.0.0.0 stehen | gewuenschte Ausgabe steht in an Stelle 10
# wenn man als Trennung der Zeichen ein Leerzeichen annimmt
GW=$(route -n | grep -v eth | grep -i "^0.0.0.0" | cut -f 10 -d " ")
# Variablen werden gesezt
PACKETS=3
STARTWERT=0
ENDWERT=5

# wenn die Variable "GW" nicht leer ist dann...
# (-z kann pruefen ob eine Variable leer ist)
if [ -n $GW ]; then
# ...solange der STARTWERT kleiner dem ENDWERT ist, wird folgendes ausgefuert
	while [ $STARTWERT -lt $ENDWERT ]; do
# schauen ob wir eine ANTWORT vom Gateway bekommen ->
# ping-test | Anzahl der zu sendenden / empfangenden Pakete | Ausgabe-Zeile auf "packets" eingrenzen | gewuenschte Ausgabe steht in an Stelle 4
# wenn man als Trennung der Zeichen ein Leerzeichen annimmt
		REQUEST=$(ping -qc $PACKETS $GW | grep packets | cut -f 4 -d " ")
# wenn die gesendeten Packete nicht der Anzahl der empfangenden entspricht...
		if [ $REQUEST != $PACKETS ]; then
# ...dann Variable = 1 -> Fehler
			EXITCODE=1
		else
# ...ansonsten Variable = 0 -> OK
			EXITCODE=0
		fi
# STARTWERT um 1 erhoehen, so dass die while-Schleife irgendwann beendet werden kann
		STARTWERT=$(expr $STARTWERT + 1)
	done
fi

# wenn alles OK war...
if [ $exitcode=0 ]; then
# ...wird lynx (Browser) mit User + Password automatisch gestartet
	gnome-terminal -e lynx -cmd_script=/home/lars/wlan.log http://www.google.de/
# und dem System wird mitgeteilt, dass alles OK ist
	exit 0
else
# bzw. dass ein Fehler aufgetreten ist
	exit 1
fi


Wenn man dieses Skript nun unter “/etc/network/if-up.d/” anlegt, und in der Datei “/etc/network/interfaces” unter dem Abschnitt z.B. “wlan0″ folgende Zeile einfügt:

post-up /etc/network/if-up.d/wlan_login.sh

…wird dieses ausgeführt, sobald das W-Lan verbunden ist. Wenn jemand noch eine bessere Möglichkeit kennt, würde ich diese gerne hören… :-)

Konsolen-Logo

Ubuntu aufräumen

Wer Ubuntu einmal aufräumen möchte, kann folgendes Skript dafür verwenden, außerdem kann man mit dem Programm localpurge überflüssige Sprach-Dateien löschen.


Nutzung auf eigene Gefahr und wie immer gilt, erst verstehen dann per “Copy&Past” kopieren!


#!/bin/bash

OLDCONF=$(dpkg -l|grep "^rc"|awk '{print $2}')
CURKERNEL=$(uname -r|sed 's/-*[a-z]//g'|sed 's/-386//g')
LINUXPKG="linux-(image|headers|ubuntu-modules|restricted-modules)"
METALINUXPKG="linux-(image|headers|restricted-modules)-(generic|i386|server|common|rt|xen)"
OLDKERNELS=$(dpkg -l|awk '{print $2}'|grep -E $LINUXPKG |grep -vE $METALINUXPKG|grep -v $CURKERNEL)
GELB="\033[1;33m"
ROT="\033[0;31m"
FARBLOS="\033[0m"

if [ $USER != root ]; then
  echo -e $ROT"Error: du bist nicht root"
  echo -e $GELB"Ende..."$FARBLOS
  exit 0
fi

echo -e $GELB"APT-Cache aufraumen..."$FARBLOS
aptitude autoclean

echo -e $GELB"nicht mehr benoetigte Abhaengigkeiten aufraumen..."$FARBLOS
apt-get autoremove

echo -e $GELB"alte Config-Dateien loeschen..."$FARBLOS
aptitude purge $OLDCONF

echo -e $GELB"alte Kernels loeschen..."$FARBLOS
aptitude purge $OLDKERNELS

echo -e $GELB"alle Trashes löschen..."$FARBLOS
rm -rf /home/*/.local/share/Trash/*/** &> /dev/null
rm -rf /root/.local/share/Trash/*/** &> /dev/null

echo -e $GELB"Alles sauber...!"$FARBLOS
Konsolen-Logo

.bashrc

Wer Einstellungen an der bash ändern möchte oder z.B. einige Kommandos bzw. die
passenden Parameter nur schwer behalten kann oder eher selten auf der
Kommandozeile arbeitet, für den sind Einträge in der .bashrc sehr hilfreich.

Global -> /etc/bash.bashrc

User -> ~/.bashrc

 

Download:

https://github.com/voku/dotfiles/blob/master/.bashrc

 

Es folgen einige Einträge welche man ggf. in der .bashrc eintragen kann

export

# Datum zum Historylog hinzufuegen
export HISTTIMEFORMAT="%F %T "
# History auf 3000 Eintraege erweitern
export HISTSIZE=3000
# keine doppelten Einträge speichern
export HISTCONTROL=ignoredups
LS_COLORS='no=00:fi=00:di=01;34:ln=01;36:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:su=37;41:sg=30;43:tw=30;42:ow=34;42:st=37;44:ex=01;32:*.tar=01;31:*.tgz=01;31:*.svgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.lzma=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.dz=01;31:*.gz=01;31:*.bz2=01;31:*.bz=01;31:*.tbz2=01;31:*.tz=01;31:*.deb=01;31:*.rpm=01;31:*.jar=01;31:*.rar=01;31:*.ace=01;31:*.zoo=01;31:*.cpio=01;31:*.7z=01;31:*.rz=01;31:*.jpg=01;35:*.jpeg=01;35:*.gif=01;35:*.bmp=01;35:*.pbm=01;35:*.pgm=01;35:*.ppm=01;35:*.tga=01;35:*.xbm=01;35:*.xpm=01;35:*.tif=01;35:*.tiff=01;35:*.png=01;35:*.svg=01; 35:*.mng=01;35:*.pcx=01;35:*.mov=01;35:*.mpg=01;35:*.mpeg=01;35:*.m2v=01;35:*.mkv=01;35:*.ogm=01;35:*.mp4=01;35:*.m4v=01;35:*.mp4v=01;35:*.vob=01;35:*.qt=01;35:*.nuv=01;35:*.wmv=01;35:*.asf=01;35:*.rm=01;35:*.rmvb=01;35:*.flc=01;35:*.avi=01;35:*.fli=01;35:*.gl=01;35:*.dl=01;35:*.xcf=01;35:*.xwd=01;35:*.yuv=01;35:*.aac=00;36:*.au=00;36:*.flac=00;36:*.mid=00;36:*.midi=00;36:*.mka=00;36:*.mp3=00;36:*.mpc=00;36:*.ogg=00;36:*.ra=00;36:*.wav=00;36:'
export LS_COLORS
# Source Globale Definitionen
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
# Schalte vervollstaendigung fuer Programme ein
if [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi

alias

alias checkupdates='sudo apt-get update'

-> aktualisiert die Quellen (sources.list)

alias mkdd='mkdir $(date +%Y%m%d)'

-> erstellt ein Verzeichnis mit angehängtem Datum (yyyymmdd)

alias launchpadkey='sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys'

-> fuegt einen neuen Key Launchpad PPAs fuer Ubuntu hinzu

z.B.: launchpadkey 4E5E17B5

alias grep='grep --color=auto'

-> Ergebnisse von grep werden nun farblich markiert

alias ls='ls --color=auto -Fh'

-> verleiht dem “ls”-Befehl Farbe

alias la='ls -laFh --color=auto'

-> zeigt alle Dateien und Verzeichnisse ausführlich an

alias ll='ls -lFh --color=auto --group-directories-first'

-> zeigt Dateien und Verzeichnisse ausführlich an

alias llr='ls -lartFh --color=auto --group-directories-first'

-> zeigt die zuletzt geänderten Dateien unten an

alias dir='ls --color=auto --format=vertical'

-> zeigt Dateien und Verzeichnisse an

alias vdir='ls --color=auto --format=long'

-> zeigt mehr Infos zu Dateien und Verzeichnissen an

alias tree='tree -Csu'

-> zeigt einen Verzeichnis-Baum an

alias timestamp='date "+%Y%m%dT%H%M%S"'

-> zeigt den aktuellen Timestamp im ISO 8601 Format an

alias lf='find ./* -ctime -1 | xargs ls -ltr --color'

-> zeigt rekursiv Dateien und Verzeichnisse die in der letzten Stunde anfasst wurden an

alias myip='GET http://www.whatismyip.com/automation/n09230945.asp && echo'

-> zeigt deine oeffentliche IP-Adresse an

alias ..='cd ../'

-> wechselt ein Verzeichnis nach oben

alias ::='cd ../..'

-> wechselt zwei Verzeichnisse nach oben

alias 'psx'='ps auxwf | grep'

-> zeigt die/den entsprechenden Prozess an

alias pst='pstree -Alpha'

-> zeigt die Prozessstruktur uebersichtlich an

alias psmy='ps -ef | grep $USER'

-> zeigt alle meine Prozesse an

alias lsport='sudo lsof -i -T -n'

-> zeigt die Ports an, welche die Applikationen verwenden

alias llport='netstat -nape --inet'

-> zeigt weitere Infos über die Ports an, welche die Applikationen verwenden

alias du='du -kh'

-> zeigt den Festplattenverbrauch eines Verzeichnisses leserlich an

alias df='df -kTh'

-> zeigt den kompletten Festplattenverbrauch leserlich an

function

# Netzwerk Info
netinfo ()
{
  echo "--------------- Network Information ---------------"
  /sbin/ifconfig | awk /'inet Adresse/ {print $2}'
  echo ""
  /sbin/ifconfig | awk /'Bcast/ {print $3}'
  echo ""
  /sbin/ifconfig | awk /'inet Adresse/ {print $4}'
  echo "---------------------------------------------------"
}
# entpacken von Komprimierten Dateien
extract()
{
  if [ -f $1 ] ; then
    case $1 in
             *.tar.bz2)   tar xvjf $1     ;;
             *.tar.gz)    tar xvzf $1     ;;
             *.bz2)       bunzip2 $1      ;;
             *.rar)       unrar x $1      ;;
             *.gz)        gunzip $1       ;;
             *.tar)       tar xvf $1      ;;
             *.tbz2)      tar xvjf $1     ;;
             *.tgz)       tar xvzf $1     ;;
             *.zip)       unzip $1        ;;
             *.Z)         uncompress $1   ;;
             *.7z)        7z x $1         ;;
             *)           echo "'$1' cannot be extracted via >extra  ct<" ;;
         esac
  else
    echo "'$1' is not a valid file"
  fi
}
# zeigt alle Dateien in dem akuellen Verzeichnis an (rekursiev)
ff()
{
  find . -type f -iname '*'$*'*' -ls ;
}
# Finde Text in Dateien
fstr()
{
  OPTIND=1
  local case=""
  local usage="fstr: find string in files.
  Usage: fstr [-i] "pattern" ["filename pattern"] "
  while getopts :it opt
    do
        case "$opt" in
        i) case="-i " ;;
        *) echo "$usage"; return;;
        esac
  done
  shift $(( $OPTIND - 1 ))
  if [ "$#" -lt 1 ]; then
    echo "$usage"
        return;
  fi
  find . -type f -name "${2:-*}" -print0 |
  xargs -0 egrep --color=always -sn ${case} "$1" 2>&- | more
}
# Infos zu einer Datei ausgeben
file_information()
{
  if [ $1 ]; then
    PLACE=`type -path $1`
    if [ -z $PLACE ]; then echo "$1: not found"; return 1; fi
      echo $PLACE
          ls -l $PLACE
          file $PLACE
        ldd $PLACE
  else
      echo "Missing argument"
  fi
}
alias finfo=file_information
# ein Backup einer Datei anlegen (mit Datum)
file_backup()
{
  for FILE ; do
    [[ -e "$1" ]] && cp "$1" "${1}_$(date +%Y-%m-%d_%H-%M-%S)" || echo ""$1" not found." >&2
  done
}
alias fback=file_backup
# Ein komprimiertes Backup + Datum erstellen
packen()
{
tar czvf "$1-$(date +%y%m%d-%H%M%S).tar.gz" "$1" ;
}
# ssh Verbindung aufbauen + ein Logfile schreiben
logssh()
{
  ssh $1 | tee sshlog ;
}
# farblichen Bash-Prompt
shell_colored() {
local GRAY="[33[1;30m]"
local LIGHT_GRAY="[33[0;37m]"
local CYAN="[33[0;36m]"
local LIGHT_CYAN="[33[1;36m]"
local NO_COLOUR="[33[0m]"
local BLUE="[33[0;34m]"
local LIGHT_BLUE="[33[1;34m]"
local RED="[33[0;31m]"
local LIGHT_RED="[33[1;31m]"
local GREEN="[33[0;32m]"
local LIGHT_GREEN="[33[1;32m]"
local PURPLE="[33[0;35m]"
local LIGHT_PURPLE="[33[1;35m]"
local BROWN="[33[0;33m]"
local YELLOW="[33[1;33m]"
local BLACK="[33[0;30m]"
local WHITE="[33[1;37m]"

PS1="n${debian_chroot:+($debian_chroot)}$LIGHT_GREENu$LIGHT_BLUE@$LIGHT_GREENh$LIGHT_GRAY:$LIGHT_BLUEw$LIGHT_RED->$NO_COLOUR "
}
shell_colored

Ubuntu benachrichtigt dich…

Dustin Kirkland, Core Developer vom Ubuntu Server hat etwas interessantes in seinem Blog geschrieben. Und zwar wie man sich über beendete Befehle in der Shell benachrichtigen lassen kann. Falls ein “make” oder “grep” … mal wieder etwas länger dauert, kann man beruhigt weiterarbeiten und wird per NotifyOSD darüber benachrichtigt, wenn der Befehl beendet wurde.

Dazu musst du als erstes folgende Datei editieren:

vim ~/.bashrc
alias alert_helper='history|tail -n1|sed -e "s/^\s*[0-9]\+\s*//" -e "s/;\s*alert$//"'
alias alert='notify-send -i /usr/share/icons/gnome/32x32/apps/gnome-terminal.png "[$?] $(alert_helper)"'
sudo apt-get install libnotify-bin
source ~/.bashrc

Und schon kannst du es testen, einfach den “alert”-Befehl inter deinen Befehl schrieben, fertig…

sleep 5; alert

Die größten dpkg-Pakete auf Ubuntu/Debian ermitteln

Folgendermaßen findest du heraus, welche bereits installierten Pakete am meisten Festplattenplatz verbrauchen:

dpkg-query --show --showformat='${Package;-50}t${Installed-Size}n' | sort -k 2 -n | grep -v deinstall | awk '{printf "%.3f MB t %sn", $2/(1024), $1}'

Speicherverbrauch anzeigen lassen

Um deinen Speicherverbrauch zu sehen gibt es viele Möglichkeiten unter Linux.

1.) Allgemeine Speicherverbrauch im MB anzeigen lassen

free -mt

2.) Detaillierten Speicherverbrauch anzeigen lassen

cat /proc/meminfo

3.) Mit dem Universal-Werkzeug

top

-> gefolgt von einem großen “M” dann werden die Prozesse auch noch nach Ihrem Speicherverbrauch sortiert

4.) Eine sortierte Ausgabe des Speicherverbrauch je Prozess

ps -e -orss=,args= | sort -b -k1,1n | pr -TW$COLUMNS

5.) Eine sortierte Ausgabe des Speicherverbrauch je Prozess (in schön)

vim ~/speicher.sh
#!/bin/bash

/usr/bin/printf "%-6s %-9s %sn" "PID" "Total" "Command"
/usr/bin/printf "%-6s %-9s %sn" "---" "-----" "-------"

for PID in `/bin/ps -e | /usr/bin/awk '$1 ~ /[0-9]+/ { print $1 }'`
do
   CMD=`/bin/ps -o comm -p ${PID} | /usr/bin/tail -1`
   TOTAL=`/usr/bin/pmap ${PID} 2>/dev/null | /usr/bin/tail -1 | /usr/bin/awk '{ print $2 }'`
   [ -n "${TOTAL}" ] && /usr/bin/printf "%-6s %-9s %sn" "${PID}" "${TOTAL}"  "${CMD}"
done | /usr/bin/sort -n -k2
chmod +x ~/speicher.sh
~/speicher.sh

In diesem Skript sollte ich das Programm “pmap” noch einmal erwähnen, mit diesem kannst du weitere Informationen zum Speicherverbrauch eines Prozesses in Erfahrung bringen.

z.B.:

ps auxf | grep apache

In der zweiten Spalte der Ausgabe finden wir jeweils die PID-Nummer des Prozesses.

pmap < PID > | grep php

nun sehen wir z.B. den Speicherverbrauch der php-Erweiterungen

Bash-Programmierung: Schleifen

Eine Endlosschleife erzeugen wir nun, indem wir einfach eine Bedingung wählen, die immer erfüllt ist… dies könnte man z.B. wie folgt machen:

while true; do date; sleep 5; done

Dies kann man jedoch auch sehr viel einfacher haben und zwar mit “watch”:

watch -n5 "date"

Wenn die Schleife jedoch noch einigen Durchläufen beendet werden soll, kann man dies z.B. so machen:

for i in`seq 1 50` ; do echo $i ; date ; sleep 5 ; done

Hier noch ein paar Beispiele:

#!/bin/sh

ANZAHL=0
echo "until-Loop"
# gt = groesser

until [ ${ANZAHL} -gt 10 ] ; do
        echo ${ANZAHL}
        ANZAHL=`expr ${ANZAHL} + 1`
done

# ------------------------------------

ANZAHL=0
echo "while-Loop"
# gt = kleiner/gleich

while [ ${ANZAHL} -le 10 ]
        do
        echo ${ANZAHL}
        ANZAHL=`expr ${ANZAHL} + 1`
done

# ------------------------------------

echo "For-Loop"
# seq = sequenz

for i in `seq 0 10`
        do
        echo $i
        done
exit

# ------------------------------------

Zum Schluss noch ein Beispiel aus der Praxis:

for I in $(ps aux|grep "apache"| awk {'print $2'}); do kill -9 $I; done

vielleicht auf den ersten Blick ein wenig konfus, aus den zweiten Blick erkennt man jedoch, dass mittels ps nach “apache” gesucht wird, die PID-Nunner per awk herausgenommen und diese Programme dann getötet werden.