BASH et outils système de base

BASH

Introduction

Nous allons parler ici de terminal, de shell et du Bourne Again SHell (BASH). Nous aborderons leur utilisation sur un poste personnel et sur un cluster de calcul.

  • Qu'entendons-nous par terminal ? C'était une machine dans le temps du minitel. C'est désormais un programme appelé moins souvent mais plus justement "émulateur de terminal". Son rôle est de gérer les entrées/sorties entre l'utilisateur et le SHELL. Un terminal réceptionne les caractères tapés au clavier par l'utilisateur, les transmet au SHELL puis met en forme la sortie sur l'écran (couleur, police...).
  • Qu'est-ce qu'un SHELL ? C'est une interface homme-machine sous la forme d'un interpréteur de langage. Il existe plusieurs SHELLS. Chacun a sa spécificité, ses avantages et inconvénients. http://fr.wikipedia.org/wiki/Shell_Unix
  • Qu'est-ce que BASH ? C'est le SHELL le plus utilisé sous GNU/Linux. Il est très souvent fourni par défaut dans les systèmes Unix (Linux, Bsd, Solaris, MacOS).
  • Et pourquoi pas une interface graphique ? Les interfaces graphiques sont construites au dessus de la ligne de commande. Elles en sont une évolution, une surcouche, un habillage... Elles apportent un aspect intuitif et ajoutent (parfois) de l'ergonomie dans l'interface homme machine. L'interface graphique n'a pas le même pouvoir d'expression que la ligne de commande. Elle est une composition figée d'un certain nombre de fonctions du SHELL. Théoriquement, avec une bonne maitrise d'un SHELL on peut faire tout ce que l'on peut imaginer (même les erreurs les plus folles).

Pourquoi BASH et pas un autre SHELL ?

Bash est une évolution du shell historique sh qui a bénéficié des grosses évolutions (historique, complétion...). Il en existe d'autres plus adaptés à une pratique spécifique. Bash est un shell avec historique et complétion intelligente.

  • Historique : On peut naviguer dans l'historique de commandes avec les flèches verticales. On peut aussi rechercher dans l'historique avec CTRL+R.
  • Complétion : On déclenche la complétion avec la touche tabulation (TAB) (*). Si on est en train d'écrire le premier "mot" de la ligne, la complétion cherche les possibilités parmi les programmes, commandes, fonctions disponibles dans le contexte courant. Si plusieurs possibilités existent pour compléter le mot, la complétion s'arrête à la plus grande partie commune des possibilités. Un deuxième appui affiche la liste des possibilités. Certaines commandes ou programmes implémentent une complétion intelligente qui complète aussi sur les options. A partir du deuxième mot de la ligne de commande, le plus souvent, la complétion se concentre sur les fichiers/dossiers.
    • Contrôle des JOBS: Une seule instance de BASH permet de gérer le lancement de plusieurs programmes et leur gestion par la suite. On peut par exemple mettre en arrière plan un programme qui tourne pour récupérer la main sur son BASH puis ensuite remettre le programme en question en avant plan. Ces aspects seront développés dans une formation future.
    • Fausses raison d'utiliser BASH
      • Il est très utilisé et répandu
    • Bonnes raisons d'utiliser BASH
      • Il est très utilisé et répandu
      • Il a une syntaxe compatible avec la plupart des autres shells
      • Il implémente quasiment toutes les évolutions majeures des autres shells

(*) Pour peu que le package bash-completion soit présent.

Pourquoi un langage different ? Pourquoi pas python ou perl ?

  • syntaxe (pseudo) épurée : paramètres sans parenthèses, concaténation sans caractère spécial, intégration transparente des regexp, wildcards...
  • SURTOUT : le PIPE est simple à utiliser. En python :
#!/usr/bin/python
from subprocess import Popen, PIPE, STDOUT
p1 = Popen(['myapp1','param'], stdout=PIPE, stdin=PIPE, stderr=PIPE)
p2 = Popen(['myapp2'], stdout=PIPE, stdin=p1.stdout, stderr=PIPE)

En bash :

myapp1 "param" | myapp2

KISS

KISS (Keep it simple, stupid).

KISS est un principe que beaucoup d'outils ou commandes sont sensés respecter. Ce principe préconise la simplicité dans la mesure du possible.

Ce principe est très utilisé dans le système GNU/Linux et il se retrouve dans la manière de spécifier les paramètres des outils. En BASH, on dispose de beaucoups d'outils simples, qui font une chose et la font bien.

Quand on copie, déplace, linke etc...on a deux paramètres évidents : source et destination. L'ordre est toujours le suivant : source destination.

cp source destination
mv source destination
ln -s quel_fichier chemin_du_lien

Un autre exemple d'application du KISS est que la commande "ls" sans paramètre liste le contenu du répertoire courant. Ou encore que la commande "cd" sans paramètre effectue un déplacement vers le répertoire personnel.

Description de la logique du terminal

  • Dans BASH, on peut lancer des utilitaires systèmes et des programmes. Par exemple, la commande "ls" sert à lister le contenu d'un dossier. La commande "blast" lance le logiciel blast.
  • Les chemins : On distingue deux types de chemins :
    • ABSOLUS : Ils commencent toujours par "/" qui est la racine de l'ordinateur. C'est le chemin complet vers le fichier/dossier que l'on veut désigner. Par exemple : /tmp/fichier0.txt
    • RELATIFS : Ils commencent par ./ ou ../ ou directement par un nom de fichier ou de dossier. Par exemple :
      • ./fichier1.txt pour un fichier dans le dossier courant
      • ../fichier2.txt pour un fichier dans le dossier parent au dossier courant
      • dossier/fichier2.txt équivaut à ./dossier/fichier2.txt
  • principe de l'invite de commande :

    • L'invite de commande se présente pour signaler à l'utilisateur que le SHELL est disponible pour recevoir un ordre. Elle a cette forme par défaut :

      nom@machine:dossiercourant$
      
    • Composition d'une ligne de commande :

      commande arg -o --option arg1
      

Le séparateur est l'espace. Pour écrire une chaine contenant des espaces il faut utiliser des guillemets (" ou ') ou bien échapper le caractère espace avec un antislash. (nous verrons ça en TP) La ligne de commande commence toujours par la commande ou le programme/logiciel à exécuter. Arrivent ensuite les paramètres qui peuvent être des options (précédés par '-') et des arguments. Dans la ligne d'exemple précédente "arg" est un argument. "-o" est une option courte sans argument. "--option" est une option longue avec argument. "arg1" est l'argument de l'option "--option".

  • principe général de l'interaction : On donne une entrée à un programme/commande et on obtient une sortie (directe ou dans un fichier). Le SHELL est un programme interactif.
  • non-interactif : lancement => exécution => résultat (fichier ou STDOUT qui est défini plus loin au niveau des redirections de sorties) => invite Un programme non-interactif prend la main, effectue sa tâche puis rend la main. La plupart de ces programmes ont des exécutions courtes (pas en bio-info).
  • interactif : lancement => lecture de STDIN => résultat => invite Un programme interactif est susceptible de demander des informations à l'utilisateur à travers l'entrée standard (clavier ou autre...nous verrons ça plus tard) pendant son exécution.
  • Les scripts : On peut écrire dans un fichier texte une succession d'opérations à effectuer, comme un programme qui serait écrit dans le langage du terminal. On peut ensuite lancer un script de cette manière :
bash mon_script.sh

Avec le fichier "mon_script.sh" qui pourrait avoir ce contenu :

mkdir exo1
cd exo1
echo "je suis dans exo1"
cd ..
rm -r exo1
echo "j'ai effacé exo1"

Les droits sur les fichiers et dossiers

On peut voir les droits des fichiers ou dossiers avec la commande "ls -l".

Sous Linux, des droits sont définis pour chaque fichier et dossier. On distingue trois droits :

  • LECTURE/READ (R)
  • ECRITURE/WRITE (W)
  • EXECUTION/EXECUTE (X)

pour trois type d'utilisateur :

  • OWNER (U) qui est le propriétaire du fichier
  • GROUP (G) qui est le groupe auquel appartient le fichier
  • OTHER (O) qui sont tous les autres utilisateurs

La combinaison des trois droits pour les trois types d'utilisateurs donne 9 caractères qui expriment les droits sur un fichier/dossier : rwxrwxrwx Les trois premiers caractères concernent le propriétaire du fichier, les suivants concernent le groupe propriétaire du fichier et les trois derniers concernent tous les autres utilisateurs. Si un caratère est présent, le droit est accordé, sinon le droit est absent.

Quelques exemples de droits courants :

  • rwx------ : seul le propriétaire a le droit de lecture, écriture, exécution sur le fichier
  • rwxr-xr-x : le propriétaire a tous les droits, les autres on seulement le droit de lecture et exécution
  • rw-r--r-- : le propriétaire peut lire et modifier, les autres peuvent seulement lire

Les droits peuvent aussi s'exprimer par trois chiffres. Pour retomber sur la représentation classique des droits, il faut traduire chaque chiffre en binaire puis faire un ET bit à bit entre le masque obtenu et la chaine rwxrwxrwx. Le chiffre binaire 1 correspondra ainsi à la présence du droit dans la chaine (rwxrwxrwx) à la même position et un 0 à son absence. Un peu obscur ? C'est normal. Avec des exemples ce n'est pas si compliqué :

  • 755 :
rwxrwxrwx
111101101
rwxr-xr-x

Ci-dessus, l'utilisateur (propriétaire) aura tous les droits sur le fichier/dossier (rwx), le Groupe d'appartenance de l'utilisateur aura les droits de parcourir/eXécuter et liRe, tout comme les autres (other est à "Read" et "eXecute").

  • 644 :
rwxrwxrwx
110100100
rw-r--r--
  • 700 :
rwxrwxrwx
111000000
rwx------

Le possesseur d'un fichier/dossier peut modifier les droits de celui ci avec la commande chmod (il est également possible de modifier les droits de propriété avec "chown").

Exemple courant de changement de droits : si on veut rendre un fichier exécutable :

chmod +x fichier.sh

Cette commande va donner le droit d'exécution au propriétaire, au groupe et aux autres.

Si on veut restreindre l'accès d'un fichier de son home pour empêcher sa lecture depuis un autre compte sur le cluster :

chmod go-rwx fichier.sh

Cette commande va enlever les droits de lecture, écriture et exécution pour le groupe et les autres.

Pour aller plus loin sur les droits : http://wiki.rotomalug.org/index.php/LPI-101-2-3#Le_mod.C3.A8le_de_permissions_Linux

Les variables, liste et dictionnaires

Comme tout langage de programmation, BASH dispose de variables. Elles ne sont pas typées et ne nécessitent pas de déclaration. On peut affecter une chaine de caractère à une variable.

# affectation
mavariable="ma valeur"

# consultation
echo $mavariable

Listes

Nous disposons aussi en BASH de la notion de liste et de dictionnaire.

# initialisation d'une liste
maliste=(zero un deux)

# consultation d'un élément
echo ${maliste[1]}
# va afficher "un"

# affectation d'un élément
maliste[3]=trois

On peut facilement générer des listes numériques en BASH :

echo {1..10}

# va afficher "1 2 3 4 5 6 7 8 9 10"

seq 1 10

# va afficher
1
2
3
4
5
6
7
8
9
10

Dictionnaires

Un dictionnaire est une liste indexée par des chaines de caractère :

declare -A couleurs=( ["vert"]="green" ["rouge"]="red" )

echo ${couleurs[vert]}

Le contexte

En BASH, aucune différence n'est faite entre les variables des utilisateurs et les variables d'environnement si ce n'est que ces dernières ont toujours des noms en majuscules.

Dans un SHELL, le résultat des actions est conditionné par le contexte courant qui est composé de l'état de toutes les variables d'environnement au moment présent. Le contexte peut être vu comme un état figé de l'environnement. La partie la plus intéressante de son contenu dans notre cas est :

  • le répertoire courant ou working directory ( $PWD )
  • le home directory ( $HOME )
  • le nom de la machine ( $HOSTNAME )
  • la langue du système ( $LANG )
  • le PATH qui est la liste des dossiers contenant les exécutables que l'on veut pouvoir appeler de n'importe quel endroit ( $PATH )
  • la chaine de paramétrage du prompt (invite de commande) ( $PS1 )
  • le nom du SHELL courant ( $SHELL )
  • le nom et id de l'utilisateur courant ( $USER et $UID )
  • Tapez env pour avoir la liste des variables d'environnement

Rappel des commandes de base ou comment survivre dans un shell

  • man ARG : donne le manuel de la commande, du programme ou de la fonction "ARG" (ex: man ls)
  • cd REP : change de répertoire. Si REP commence par "/" on parle de chemin absolu, sinon de chemin relatif au CWD (current working directory).
  • mkdir REP : crée un répertoire
  • cp REP_SRC REP_DEST : copie un fichier ou un répertoire (option -r)
  • mv SRC DEST : déplace un fichier ou un répertoire et permet le renommage à la volée
  • rm FILE : supprime
  • ls REP : liste le contenu d'un répertoire. Si REP n'est pas fourni, liste le répertoire courant.
  • df : "disk free" donne des informations sur l'espace libre sur les partitions montées du système
  • du REP : "disk usage" donne la taille de REP
  • cat FILE : affiche le contenu textuel du fichier FILE
  • concaténer deux fichiers : cat FILE1 FILE2 > FILE3

Boucles et conditions

Un retour à la ligne peut être remplacé par un ";" si on veut écrire sur la même ligne. Voila les syntaxes :

for VAR in LISTE_DE_VALEURS; do
   actions
done

if CONDITION; then
    actions
fi

Et quelques exemples :

for i in 2 3 8 9 10; do
    echo  i est =  $i
done

for i in A B C D Z; do
    mkdir dossier_$i
done

for i in 2 3 8 9 10; do
    if [ -d dossier_$i ]; then
        rm -r dossier_$i
    fi
done

# Peut aussi s'écrire :

for i in 2 3 8 9 10; do
    test -d dossier_$i && rm -r dossier_$i
done

Les fonctions

Il est possible de faire des fonctions en BASH, nous n'entrerons pas dans les détails. Si vous voulez aller plus loin :

Les wildcards

Ce sont des caractères spéciaux qui vont exprimer une ou plusieurs chaines de caractère de façon très concise et puissante. Il en existe deux types , ceux du SHELL et les expressions régulières utilisées par des outils comme sed. Mini guide sur les wildcards : http://tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm . Exemples basiques de wildcards :

du -sh *
du -sh a*
du -sh *.fa

#afficher tous les fichier txt d'un dossier:
ls /usr/share/galaxy-server/test-data/*.txt

for i in `ls /usr/share/galaxy-server/test-data/*.txt`
do
  basename $i
done

PS: Concernant la première ligne, vous pouvez également lancer cette dernière de manière "détaché" du terminal (en précédant la ligne avec nohup (voir également disown)). Si vous oubliez de lancer un programme en arrière plan, mais que vous souhaitez reprendre la main, vous pouvez l'envoyer quand même en arrière plan par la combinaison ctrl+Z puis "bg".

Exercices BASH

Exemples

  • exemples de manipulation de variables :
  # les lignes qui commencent par # sont des commentaires
  a=1; echo $a
  b=$a; echo $b
  a="un deux trois"; echo $a
  echo $a $b
  echo $a$b
  seq 1 3;
  c=`seq 1 3`
  for i in $c
  do
   echo $i
  done

  # un tableau
  bases=()
  bases[0]=A
  bases[1]=C
  bases[2]=G
  bases[3]=T
  echo ${bases[1]}
  echo ${bases[@]}

  # Un tableau initialisé à la déclaration
  bases=(A C G T)
  echo ${bases[1]}
  echo ${bases[@]}

  # Une variable résultat d'une opération mathématique
  # $RANDOM est une variable qui prend une valeur entre 0 et 32767
  # x % y donne le reste de la division entière de x par y
  b=$((RANDOM % 4))
  echo ${bases[b]}

  # Pour générer une séquence aléatoire de 200 bases equi-fréquentes
  sequence=""
  for j in `seq 1 200`
  do
    b=$[ RANDOM % 4 ]
    sequence=$sequence${bases[b]}
  done
  echo $sequence
  • système de fichier
mkdir mon_dossier
mkdir /tmp/mon_dossier
ls /tmp/
ls /tmp/mon_dossier
# crée un fichier vide
touch /tmp/mon_dossier/fichier1.txt
mv /tmp/mon_dossier/fichier1.txt ./
cp fichier1.txt fichier2.txt
rm ./fichier1.txt
  • boucles et conditions
i=10
while (( i > 0 )); do
    echo $i
    (( i-- ))
done

for ((i=10; i>0; i--))
do
    echo $i
done

for i in `seq 10 -1 1`; do
    echo $i
done

# les conditions
i=$RANDOM
if [ $i -gt 10 ]
then
    echo "La valeur de i est > 10"
else
    echo  "La valeur de i est <= 10"
fi

A votre tour

  • Générez et affichez 100 valeurs aléatoires comprises entre 0 et 10
  • Créez un tableau de 100 valeurs aléatoires comprises entre 0 et 10.
  • Créez un tableau qui contient les valeurs du tableau précédent préfixées par le texte "pair" si la valeur est paire
  • Faites une boucle qui compte le nombre de fois qu'on a un nombre pair sur 100 000 nombres aléatoires. Indice :
    # pour faire un compteur :
    compteur=0
    ((compteur++))
    ((compteur++))
    # maintenant le compteur vaut 2
    
  • écrire un script qui effectue plusieurs opérations Pour cela il faut éditer un fichier texte. Ensuite, pour l'exécuter, deux solutions s'offrent à vous :
  • Le rendre exécutable et le lancer comme un programme classique :
chmod +x mon_script.sh
./mon_script.sh
  • Une autre manière de l'exécuter :
bash mon_script.sh
  • Créer cent dossiers resu1 à resu100 dans votre home.
  • Créer cent dossier resu0, resu2, resu4 et ainsi de suite avec tous les nombres pairs.

  • Ecrire un script qui prend un paramètre et crée 10 dossiers dont le nom est préfixé par ce paramètre.

Exercices supplémentaires :

  • Générer une séquence aléatoire de 100 bases avec une probabilité de 70% pour la base 'A' et 10% pour chacune des autres. Indication : voila un if avec un ET entre deux conditions :
    if ((2 < n)) && ((n < 30)); then
    

Les entrées sorties. Le chainage des operations avec le PIPE

entrees_sorties_form3

(la redirection de la sortie erreur vers un pipe n'est possible que si elle est combinée avec la sortie standard)

http://www.tuteurs.ens.fr/unix/shell/entreesortie.html

Les sorties standard et d erreur

Un programme ou une commande peut produire un résultat sous forme de fichier. Elle peut aussi écrire dans sa sortie standard ou sa sortie d'erreur. Dans un terminal, la sortie standard du programme en cours d'exécution est affichée à l'écran. Nous verrons ensuite comment rediriger cette sortie standard dans l'entrée standard d'un autre programme.

Un programme peut aussi produire des messages dans sa sortie d'erreur. Par defaut, cette sortie d'erreur est présentée à l'écran avec la sortie standard sans signe distinctif. Elle sert en général à indiquer ce qui se passe mal pendant l'exécution du programme. On peut la rediriger également à sa guise.

Quelques exemples de sorties:

# prenon la commande ls par exemple
# le cas classique, elle affiche son résultat sur la sortie standard :
ls /tmp


# mais si on lui demande de lister les fichiers dans un dossier qui n'existe pas :
ls /TMP

ls: impossible d'accéder à /TMP: Aucun fichier ou dossier de ce type

# la sortie est écrite sur la sortie d'erreur.
# on ne peut pas différencier la sortie standard et d'erreur à l'oeil nu.

Redirection des sorties dans des fichiers (> et >>)

Lorsqu'un programme veut communiquer un texte directement à l'utilisateur, il le fait par la sortie standard (STDOUT) qui s'affichera sur le terminal par défaut. Il peut aussi écrire sur STDERR, la sortie d'erreur. Parfois on a besoin de garder une information dans un fichier pour l'utiliser ensuite avec un autre programme. BASH permet de facilement écrire la sortie (textuelle ou non) d'un programme dans un fichier avec le caractère ">".

ls > fichier

Si le fichier n'existe pas, il sera créé. S'il existe il sera écrasé. Le caractère ">>" permet de concaténer, d'écrire à la suite d'un fichier.

for i in *; do
    echo `du -sh "$i"` >> tailles
done

On aurait pu plus simplement écrire :

du -sh * > tailles

pour aller plus loin : On peut rediriger STDOUT et/ou STDERR vers un fichier :

# Rediriger la sortie erreur dans un fichier:
ls -l /a/b/c/* 2> error.log

# Rediriger la sortie standard ET la sortie d'erreur dans un fichier
programme > fichier 2>&1

L entrée standard

Il existe deux manières de présenter des données en entrée à un programme/fonction/script :

  • Les paramètres d'appel, par exemple :

    ls /tmp/
    
  • L'entrée standard

Tous les programmes acceptent des paramètres d'appel. Certains programmes acceptent des données en entrée standard.

Prenons l'exemple de "sort" qui peut prendre un paramètre à l'appel, le nom du fichier dont on doit trier le contenu mais qui accepte aussi des données en entrée standard.

On peut donner à sort un fichier à trier en paramètre à l'appel :

sort fichier.txt

On peut passer des données en entrée standard avec le caractère "<" :

sort < fichier.txt

On peut passer en entrée standard des données provenant d'un autre programme avec le PIPE :

cat fichier1.txt fichier2.txt | sort

Cela va trier ce qui provient de la commande cat c'est à dire le contenu des deux fichiers texte. Le résultat de sort est affiché à l'écran.

Les back quotes ou accents graves

Les back quotes (aussi appelés accents graves) sont un moyen simple de remplacer une commande par son résultat dans BASH.

Par exemple, je veux créer un fichier avec la commande "touch" dont le nom est l'année courante que j'obtiens avec la commande "date +%Y".

touch `date +%Y%m%d`

# affichage du dossier
ls
# un nouveau fichier avec la date d'aujourd'hui a été créé

Le PIPE

Il est représenté par le caractère "|". Il sert à connecter deux programmes en envoyant la sortie standard du premier vers l'entrée standard du deuxième. Exemples :

Pour compter le nombre de lignes dans un fichier

wc -l fichier

Pour obtenir les identifiants des séquences dans un fichier fasta :

  • extraire uniquement les lignes des identifiants

    grep ">" omm.fasta > idents.txt
    
  • compter ces identifiants :

    wc -l idents.txt
    

Pour éviter de créer des fichiers intermédiaires :

grep ">" fichier.fas | wc -l
  • compter les identifiants uniques :

    grep ">" fichier.fas | uniq | wc -l
    
  • calculer les stats résumées à l'aide de R sur une colonne de valeurs numériques:

    • ceci est un alias d'une commande R pour calculer des stats sur la 1° colonne d'une data frame lue à partir de l'entrée standard
      alias stats='Rscript -e "summary(as.numeric(read.table(file(\"stdin\"))[,1]))"'
      
    • Extraire la 5° colonne (MAPQ) d'un résultat de mapping et la donner comme entrée à notre alias
      cut -f5 resu.sam | stats
      
  • Dessiner un histogramme le résultat sera dans Rplots.pdf

    alias histo='Rscript -e "summary(as.numeric(read.table(file(\"stdin\"))[,1]))"'
    cut -f5 resu.sam | histo
    
  • Dessin interactif si session graphique (connexion ssh -Y)

    alias histo='Rscript -e "X11();hist(as.numeric(read.table(file(\"stdin\"))[,1])); locator()"'
    cut -f5 resu.sam | histo
    
  • dessiner une colonne d'un fichier à l'aide de gnuplot :

    echo  " plot 'resu.sam' using 5  " | gnuplot -persist
    
  • dessiner des données issues d'une autre commande bash :

    echo -e " plot '-' using 1 \n `for i in {1..50}; do echo $RANDOM; done`  " | gnuplot -persist
    

ATTENTION La sortie d'erreur ne sera pas lue lors d'une redirection dans un PIPE. bash

Plus d'informations : http://ryanstutorials.net/linuxtutorial/piping.php http://wiki.bash-hackers.org/howto/redirection_tutorial http://www.dsj.net/compedge/shellbasics1.html


exercices PIPE

  • Compter le nombre de lignes dans le fichier test.fastq REPONSE
wc -l test.fastq

ou bien avec un PIPE :

cat test.fastq | wc -l
  • Compter le nombre de séquences dans le fichier test.fastq
grep "^@" test.fastq | wc -l
  • Faire la même chose et stocker le résultat dans un fichier resu.txt

  • Extraire uniquement les séquences (sans les identifiants) du fichier omm.fasta (utilisez grep -v)

  • Quelle est la valeur max de MAPQ (5° colonne dans le fichier resu.sam) ?

  • Compter le nombre de séquences ne contenant pas le mot "rand" dans le fichier test.fastq

  • Compter le nombre de fichiers dans votre dossier personnel (utilisez ls -A pour voir tous les fichiers)

  • Compter le nombre de fichiers dont le nom commence par "." dans votre dossier personnel (indice : l'expression à donner à grep est : "^.")

Manipulation de fichiers, archivage, compression

recherche avec find

Find recherche des fichiers ou dossiers à partir d'un point de départ.

Voila la syntaxe classique de find :

find ./ -name "*.txt"

qui va chercher à partir du dossier courant tous les fichiers dont le nom se termine par ".txt".

archivage avec TAR

tar est la commande d'archivage par excellence. Elle permet de regrouper plusieurs fichiers/dossier dans une archive qui se présente sous la forme d'un fichier.

Par défaut, tar n'utilise pas de compression. La taille d'une archive est donc à peu près égale à la somme des tailles des éléments qu'elle contient.

syntaxe :

# créer une archive
tar cvf archive.tar  elem1.txt elem2.txt dossier1 dossier2

# désarchiver ou extraire (va créer tous les éléments contenu dans l'archive dans le dossier courant)
tar xvf archive.tar

# lister le contenu d'une archive :
tar -tvf archive.tar

options :

  • x : extract
  • c : create
  • v : verbose
  • f : file
  • t : list

Dans le chapitre suivant, la compression avec TAR est abordée.

compression

La compression est une opération ayant pour but de diminuer la taille d'un fichier.

L'archivage et la compression sont deux opérations différentes et séparées. On peut compresser un fichier sans l'ajouter à une archive.

Plus de détails : http://fr.wikipedia.org/wiki/Compression_de_données

zip

La commande zip permet de compresser uniquement en créant une archive. A l'inverse, la commande unzip permet de décompresser une archive zip.

gzip, bzip2

Les commandes gzip et bzip2 permettent de compresser un fichier. Une fois le fichier compressé, son nom sera suffixé de ".gz" ou ".bz2".

Pour décompresser avec ces outils, on dispose des commandes gunzip et bunzip2.

La différence entre les deux est l'algorithme de compression. La compression est plus ou moins efficace et rapide en fonction de cet algorithme et du type de fichier.

La commande tar est capable d'utiliser gzip et bzip2 au moment de la création d'une archive avec les options "z" et "j".

tar czvf archive1.tar.gz  elem1 elem2
tar cjvf archive1.tar.bz2  elem1 elem2

A la décompression, tar détecte tout seul le type de compression, pas besoin de préciser l'option j ou z.


exercices fichiers

  • Ecrire un script qui récupère le fichier des exemples : http://mbb.univ-montp2.fr/MBB/uploads/formationBash.tar.gz puis décompresse son contenu dans un dossier nommé "data" et enfin change les droits des fichiers pour n'être visible que par vous

  • Comparer le taux de compression du fichier test.fastq à l'aide des commandes zip, gzip et bzip2.

  • Extraire les séquences dont l'identifiant contient "rand" du fichier Gzippé sans le décompresser (zcat).