Opérations et tests du système de fichiers Shell

Introduction

Dans cet atelier, vous allez apprendre à effectuer divers tests de fichiers au sein du shell. Les tests de fichiers sont des outils essentiels pour vérifier les propriétés des fichiers et des répertoires dans le système de fichiers. À l'issue de cet atelier, vous serez familiarisé avec les commandes de test de fichiers les plus courantes et leur utilisation, des compétences fondamentales pour manipuler des fichiers dans des environnements Linux.

Création d'un fichier de test

Avant de commencer les opérations sur les fichiers, il est important de comprendre notre environnement de travail. Sous Linux, vous travaillez toujours dans un répertoire spécifique, et il est crucial de savoir où vous vous situez dans l'arborescence du système de fichiers.

Ouvrez un terminal dans le WebIDE. C'est ici que vous saisirez vos commandes.
Créez un nouveau fichier nommé test_file.txt :
```
touch test_file.txt
```
La commande touch est utilisée pour créer un fichier vide. Si le fichier existe déjà, elle met à jour l'horodatage du fichier sans modifier son contenu.
Ajoutez du contenu au fichier :
```
echo "This is a test file for our lab." > test_file.txt
```
Cette commande utilise echo pour afficher le texte, et > pour rediriger cette sortie vers le fichier. Soyez prudent avec >, car il écrasera tout contenu existant dans le fichier.
Vérifiez le contenu du fichier :
```
cat test_file.txt
```
cat est l'abréviation de "concatenate" (concaténer), mais elle est souvent utilisée pour afficher le contenu d'un fichier. Vous devriez voir le message "This is a test file for our lab."

Si vous faites une erreur ou si vous souhaitez recommencer, vous pouvez toujours supprimer le fichier avec rm test_file.txt et reprendre à partir de l'étape 1.

Tester l'existence d'un fichier

Maintenant que nous avons créé un fichier, apprenons à vérifier s'il existe. C'est une tâche courante dans les scripts shell, en particulier lorsque vous devez effectuer des opérations sur des fichiers.

Créez un nouveau fichier de script nommé file_exists.sh :
```
touch file_exists.sh
```
Ajoutez le contenu suivant au fichier :
```
#!/bin/bash

filename="test_file.txt"
if [ -e "$filename" ]; then
  echo "$filename exists"
else
  echo "$filename does not exist"
fi
```
Analysons ce code :
- #!/bin/bash est appelé un "shebang". Il indique au système qu'il s'agit d'un script bash.
- Nous définissons une variable filename avec la valeur "test_file.txt".
- L'instruction if vérifie si le fichier existe. -e est un test qui renvoie vrai si le fichier est présent.
- Nous utilisons echo pour afficher un message selon que le fichier existe ou non.
Enregistrez le fichier et quittez l'éditeur.
Rendez le script exécutable :
```
chmod +x file_exists.sh
```
Exécutez le script :
```
./file_exists.sh
```
Vous devriez voir le résultat : "test_file.txt exists"
Testons maintenant avec un fichier inexistant. Tout d'abord, renommons notre fichier de test :
```
mv test_file.txt non_existent.txt
```
Cette commande renomme test_file.txt en non_existent.txt.
Modifiez le script pour vérifier le nom de fichier original "test_file.txt" :
```
nano file_exists.sh
```
Modifiez la variable filename pour qu'elle soit "test_file.txt" si ce n'est pas déjà le cas.
Exécutez à nouveau le script :
```
./file_exists.sh
```
Vous devriez voir le résultat : "test_file.txt does not exist"

Ce script démontre comment vérifier l'existence d'un fichier, ce qui est crucial lorsque votre script doit manipuler des fichiers qui peuvent être absents.

Tester l'existence d'un répertoire

Tout comme pour l'existence d'un fichier, nous pouvons vérifier si un répertoire existe. Cela est utile lorsque votre script doit travailler avec des dossiers qui ne sont pas forcément présents.

Créez un nouveau fichier de script nommé dir_exists.sh :
```
touch dir_exists.sh
```
Ajoutez le contenu suivant au fichier :
```
#!/bin/bash

dirname="test_directory"
if [ -d "$dirname" ]; then
  echo "$dirname exists"
else
  echo "$dirname does not exist"
fi
```
Ce script est très similaire au précédent, mais il utilise -d au lieu de -e. Le test -d vérifie spécifiquement l'existence d'un répertoire.
Enregistrez le fichier et quittez l'éditeur.
Rendez le script exécutable :
```
chmod +x dir_exists.sh
```
Exécutez le script :
```
./dir_exists.sh
```
Vous devriez voir le résultat : "test_directory does not exist"
Maintenant, créons le répertoire et exécutons à nouveau le script :
```
mkdir test_directory
./dir_exists.sh
```
Vous devriez maintenant voir le résultat : "test_directory exists"

mkdir est la commande pour créer un nouveau répertoire.

Ce script montre comment vérifier l'existence d'un répertoire. Cela peut être particulièrement utile dans les scripts qui doivent créer, modifier ou supprimer des dossiers.

Tester les permissions de fichiers

Sous Linux, chaque fichier et répertoire possède des permissions associées qui déterminent qui peut les lire, les modifier ou les exécuter. Dans cette étape, nous allons apprendre à vérifier les permissions, et plus précisément si un fichier est lisible.

Tout d'abord, redonnons à notre fichier son nom d'origine :
```
mv non_existent.txt test_file.txt
```
Créez un nouveau fichier de script nommé file_readable.sh :
```
touch file_readable.sh
```

Ajoutez le contenu suivant au fichier :

#!/bin/bash

filename="test_file.txt"
if [ -r "$filename" ]; then
  echo "You have read permission for $filename"
else
  echo "You do not have read permission for $filename"
fi

Ce script utilise le test -r, qui vérifie si le fichier est lisible par l'utilisateur actuel.

Enregistrez le fichier et quittez l'éditeur.
Rendez le script exécutable :
```
chmod +x file_readable.sh
```
Exécutez le script :
```
./file_readable.sh
```
Vous devriez voir le résultat : "You have read permission for test_file.txt"
Maintenant, supprimons la permission de lecture et exécutons à nouveau le script :
```
chmod -r test_file.txt
./file_readable.sh
```
Vous devriez maintenant voir le résultat : "You do not have read permission for test_file.txt"

chmod -r retire les droits de lecture du fichier.
Restaurez la permission de lecture :
```
chmod +r test_file.txt
```
Il est important de restaurer les permissions pour ne pas laisser accidentellement notre fichier illisible.

Ce script démontre comment vérifier les permissions d'un fichier. Comprendre et gérer les permissions est crucial pour la sécurité du système et le bon fonctionnement des scripts.

Résumé

Dans cet atelier, vous avez appris à effectuer des opérations essentielles sur le système de fichiers via le shell. Vous avez créé des scripts pour tester l'existence de fichiers et de répertoires, ainsi que les permissions de fichiers. Ces compétences sont fondamentales pour travailler avec des fichiers et des dossiers dans des environnements Linux et constituent la base de tâches de scripting shell plus complexes.

Vous avez pratiqué :

La compréhension de votre environnement de travail
La création et la manipulation de fichiers
L'écriture et l'exécution de scripts shell
Le test d'existence de fichiers et de répertoires
La vérification des permissions de fichiers

Ces compétences vous seront précieuses au fur et à mesure que vous continuerez à travailler sur des systèmes Linux et à développer des scripts shell plus avancés. N'oubliez pas de toujours vérifier l'existence d'un fichier ou d'un répertoire avant d'effectuer des opérations dessus afin d'éviter les erreurs dans vos scripts. De plus, soyez attentif aux permissions lorsque vous manipulez des données sensibles ou des fichiers système.

Pour progresser, vous pourriez explorer des tests de fichiers plus avancés, apprendre d'autres structures de scripting shell comme les boucles et les fonctions, et vous entraîner à combiner ces concepts pour créer des scripts plus complexes et puissants.

Opérations sur le système de fichiers en Shell