wiki/TipsShell.md

# Astuces SHell

## Script

Style guide : <https://google.github.io/styleguide/shell.xml>

## Configuration

### Initialisation du shell

Entre les 3 modes ("login", "interactive non-login" et "non-interactive non-login") il y a de quoi se perdre à propos des fichiers chargés. Voici un rappel assez complet : <https://github.com/rbenv/rbenv/wiki/Unix-shell-initialization>

### History Bash

`bashrc` :

~~~
export HISTCONTROL=$HISTCONTROL${HISTCONTROL+,}ignoreboth
export HISTSIZE=65535
export HISTTIMEFORMAT="%c : " 
~~~

> *Note* : si besoin on peut `chattr +a /root/.bash_history` pour empêcher sa suppression

### Changer l'éditeur de texte par défaut pour une commande

Normalement le script (vipw, vigr, -ldapvi, ...) se réfère aux fichiers scripts (qui ne sont que des liens vers les binaires) :

~~~{.bash}
/etc/alternatives/
~~~

Sinon en ligne de commande :

~~~{.bash}
$ EDITOR=nano vipw
~~~

## Manipulations

### Tâches de fond

~~~{.bash}
$ bg = "mettre en arrière plan"
$ fg = "mettre en premier plan"
$ jobs = "lister les tâches de fond"
%% = "dernier job utilisé (représenté par un +)"
%x = "job numéro x"
~~~

~~~{.bash}
$ vi foo
^Z
[1]+  Stopped                 vi foo
$ tail -f bar
...
^C
$ fg
^Z
[1]+  Stopped                 vi foo
$ kill -9 %%

[1]+  Killed                 vi foo
$ ( sleep 1m; echo "Premier !" ) &
[1] 13649
$ ( sleep 30; echo "Deuxième !" ) &
[2] 13651
$ jobs
[1]-  Running                 sleep 1m && echo ...
[2]+  Running                 sleep 30 && echo ...
$ fg %2
^Z
[2]+  Stopped                 sleep 30 && echo ... 
$ jobs
[1]-  Running                 sleep 1m && echo ...
[2]+  Stopped                 sleep 30 && echo ...
$ sleep 30; bg
Premier !
[2]-  Done                    sleep 30 && echo ...
Deuxième !
$ jobs
[1]-  Done                    sleep 1m && echo ...
$ vi foo
^Z
[1]+  Stopped                 vi foo
$ exit
There are stopped jobs.
$ kill -9 %% #fg :x
$ exit
~~~

## Fichiers et FS

### Ordinaire 

#### Savoir si lignes en doublon dans un fichier

~~~{.bash}
$ uniq -d <fichier>
~~~

ou autrement (appliquer un filtre différent) :

~~~{.bash}
$ diff <fichier> <(cat <fichier> | uniq)
~~~

#### Comparer deux fichiers quant à l'existence de nouvelles lignes

~~~{.bash}
$ grep -F -x -v -f <fichier1> <fichier2>
~~~

#### Supprimer des vieux fichiers

 - Par exemple, si + vieux de 30 jours en modification :

~~~{.bash}
$ find DIR/ -type f -mtime +30 -delete
$ find DIR/ -type f -mtime +30 -exec rm '{}' \;
~~~

#### Comparer deux fichiers à travers SSH

~~~{.bash}
$ diff <fichier> <(ssh REMOTE cat <fichier>)
~~~

### Répertoire

#### Surveiller les ouvertures/écriture des fichiers présent dans un répertoire

~~~{.bash}
$ iwatch <target>
~~~

#### Savoir les différents users qui ont écris dans /tmp

~~~{.bash}
$ stat -c %U /tmp/* | sort | uniq -c | sort -n
~~~

#### Comparer deux répertoires à travers SSH

Générique :

~~~{.bash}
$ DIR=$PWD
$ for file in $(rsync -rvn $DIR REMOTE:$DIR | grep -v "^skipping non-regular file" | head -n -2); do echo $DIR/$file :; diff $DIR/$file <(ssh REMOTE cat $DIR/$file); done
~~~

Pour /etc/ :

~~~
# for file in $(rsync -rvn /etc/ --exclude=*.log --exclude=ssh --exclude=ssl --exclude=.git --exclude=shadow* --exclude=gshadow* REMOTE:/etc/ | \
grep -v "^skipping non-regular file" | head -n -2); do \
echo /etc/$file :; diff /etc/$file <(ssh REMOTE cat /etc/$file); done
~~~

### Espace et Inode

#### Analyse disque

Quand il s'agit de / - penser à exclure les autres partitions (si existante de toute évidence) :

~~~
# ncdu / --exclude /home --exclude /srv --exclude /var --exclude /tmp --exclude /boot
~~~

Pour certaines anciennes versions :

~~~
# ncdu --exclude "/home/*" /
~~~ 

Sinon voir du côté de [HowtoDUC](/HowtoDUC).

#### Tester l'écriture disque

Simplement, en écriture (fichier de 5.1GB) :

~~~{.bash}
$ dd if=/dev/zero of=test count=10000000
~~~

#### Lister les répertoires ayant le plus de fichiers <=> max inode

~~~{.bash}
PATH_TO_WATCH='/var'
RESULT_FILE='list_max_inode.txt'
TMP=$(mktemp)
#Regarder dans le premier niveau
(for i in $(find $PATH_TO_WATCH -type d); do echo $(ls -a $i | wc -l) $i; done) | sort -n > $TMP
#compter dans les sous niveaux
cat $TMP | (while read line; do num=$(echo $line | awk '{ print $1 }'); path=$(echo $line | awk '{ print $2 }'); echo ${path%/*}; done) | sort | uniq | (while read line; do echo $(grep "$line" $TMP | cut -f1 -d' ' | xargs echo -n | tr -s ' ' '+' | xargs echo | bc -l) $line; done) | sort -n | tee $RESULT_FILE
rm $TMP
~~~

## Utilisateurs UNIX

### Lister les utilisateurs + groupe

#### UNIX

~~~{.bash}
$ for user in $(getent passwd | awk -F ':' '$3 > 10000 {printf $1 " "}'); do groups $user; done
~~~

#### LDAP

~~~{.bash}
$ for user in $(getent passwd | awk -F ':' '$3 > 10000 {printf $1 " "}'); do \
ldapsearch -x -h localhost -LLL -b "dc=MACHINE,dc=DOMAIN,dc=COM" cn | tail -n2 | \
tr '\n' ' ' | cut -d':' -f2 | echo -n "$(cat <&0)"; echo = $(groups $user); done
~~~

## Serveur web 

### Avoir un rendu des requêtes par IP à partir d'un access.log

Avoir un compte rendu pour un laps de temps :

~~~
# date; (timeout 60 tail -f /var/log/apache2/access.log | cut -d' ' -f1) | sort | uniq -c | sort -n
~~~

Ou regarder les IPs en direct :

- Version simple :

~~~
# tail -f /var/log/apache2/access.log | stdbuf -oL cut -d ' ' -f1 | uniq -c 
~~~

- Version couleur :

~~~
# SEUIL=5; tail -f /var/log/apache2/access.log | stdbuf -oL cut -d ' ' -f1 | stdbuf -oL uniq -c | \
eval "awk '\$1 > $SEUIL {printf \"\\033[1;31m\" \$1 \" \"  \$2 \"\\033[0m \\n\"; next;};{printf \$1 \" \" \$2 \"\\n\";}'"
~~~

## Process

### Un processus par rapport à une socket/port

- Connaître les sockets ouvertes et ports en écoutent par un processus : 

~~~{.bash}
$ lsof -Pan -p PID -i
~~~

- Connaître le pid qui écoute sur un port (2ème colonne) :

~~~{.bash}
$ lsof -i :Port
~~~

### Surveiller les nouveaux processus créés

- Lister simplement :

~~~{.bash}
$ ps -e -o etimes=,pid,cmd | sort -rn | awk '{if ($1!=0 && $3!~/\[.*\]/)  print $0 }'
~~~

- Watch :

Toutes les 5 secondes :

~~~{.bash}
$ watch -n 5 -d "ps -e -o etimes=,pid,cmd | sort -n | awk '{if (\$1==0 || \$2==$$ || \$3~/watch/ || \$3~/\[.*\]/) {} else print \$0 }'"
~~~