Operaciones y Pruebas del Sistema de Archivos en Shell

Introducción

En esta práctica de laboratorio, aprenderás a realizar diversas pruebas de archivos en la shell. Las pruebas de archivos son herramientas esenciales para verificar las propiedades de archivos y directorios dentro del sistema de archivos. Al concluir esta sesión, estarás familiarizado con los comandos de prueba más comunes y su uso, habilidades que son fundamentales para trabajar en entornos Linux.

Esta es una Práctica Guiada, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que esta es una práctica de nivel principiante con una tasa de finalización del 99%. Ha recibido una tasa de valoraciones positivas del 100% por parte de los alumnos.

Creación de un Archivo de Prueba

Antes de comenzar con las operaciones de archivos, es importante comprender nuestro entorno de trabajo. En Linux, siempre estás operando dentro de un directorio específico, y es crucial saber en qué parte del sistema de archivos te encuentras.

Abre una terminal en el WebIDE. Aquí es donde escribirás tus comandos.
Crea un nuevo archivo llamado test_file.txt:
```
touch test_file.txt
```
El comando touch se utiliza para crear un archivo vacío. Si el archivo ya existe, actualiza la marca de tiempo del archivo sin modificar su contenido.
Agrega algo de contenido al archivo:
```
echo "This is a test file for our lab." > test_file.txt
```
Este comando utiliza echo para generar el texto y > para redirigir esa salida hacia el archivo. Ten cuidado con >, ya que sobrescribirá cualquier contenido previo que tenga el archivo.
Verifica el contenido del archivo:
```
cat test_file.txt
```
cat es la abreviatura de "concatenate" (concatenar), pero se usa frecuentemente para mostrar el contenido de un archivo. Deberías ver el mensaje "This is a test file for our lab."

Si cometes un error o deseas empezar de nuevo, siempre puedes eliminar el archivo con rm test_file.txt y repetir el primer paso.

Comprobación de la Existencia de Archivos

Ahora que hemos creado un archivo, aprendamos cómo verificar si existe. Esta es una tarea común en los scripts de shell, especialmente cuando necesitas realizar operaciones sobre archivos específicos.

Crea un nuevo archivo de script llamado file_exists.sh:
```
touch file_exists.sh
```
Agrega el siguiente contenido al archivo:
```
#!/bin/bash

filename="test_file.txt"
if [ -e "$filename" ]; then
  echo "$filename exists"
else
  echo "$filename does not exist"
fi
```
Analicemos el código:
- #!/bin/bash se conoce como shebang. Indica al sistema que este es un script de bash.
- Definimos una variable filename con el valor "test_file.txt".
- La sentencia if comprueba si el archivo existe. -e es una prueba que devuelve verdadero si el archivo está presente.
- Usamos echo para imprimir un mensaje dependiendo de si el archivo existe o no.
Guarda el archivo y sal del editor.
Otorga permisos de ejecución al script:
```
chmod +x file_exists.sh
```
Ejecuta el script:
```
./file_exists.sh
```
Deberías ver la salida: "test_file.txt exists"
Ahora, probemos con un archivo que no existe. Primero, renombraremos nuestro archivo de prueba:
```
mv test_file.txt non_existent.txt
```
Este comando renombra test_file.txt a non_existent.txt.
Modifica el script para que siga buscando el nombre de archivo original "test_file.txt":
```
nano file_exists.sh
```
Asegúrate de que la variable filename esté configurada como "test_file.txt".
Ejecuta el script de nuevo:
```
./file_exists.sh
```
Deberías ver la salida: "test_file.txt does not exist"

Este script demuestra cómo verificar la existencia de un archivo, lo cual es vital cuando tu script depende de archivos que podrían no estar presentes.

Comprobación de la Existencia de Directorios

De manera similar a la comprobación de archivos, también podemos verificar si un directorio existe. Esto resulta útil cuando tu script necesita trabajar con carpetas que podrían no haber sido creadas aún.

Crea un nuevo archivo de script llamado dir_exists.sh:
```
touch dir_exists.sh
```
Agrega el siguiente contenido al archivo:
```
#!/bin/bash

dirname="test_directory"
if [ -d "$dirname" ]; then
  echo "$dirname exists"
else
  echo "$dirname does not exist"
fi
```
Este script es muy parecido al anterior, pero utiliza -d en lugar de -e. La prueba -d verifica específicamente la existencia de un directorio.
Guarda el archivo y sal del editor.
Otorga permisos de ejecución al script:
```
chmod +x dir_exists.sh
```
Ejecuta el script:
```
./dir_exists.sh
```
Deberías ver la salida: "test_directory does not exist"
Ahora, crea el directorio y ejecuta el script nuevamente:
```
mkdir test_directory
./dir_exists.sh
```
Ahora deberías ver la salida: "test_directory exists"

mkdir es el comando para crear un nuevo directorio.

Este script muestra cómo validar la presencia de directorios, algo especialmente útil en procesos que requieren crear, modificar o eliminar carpetas.

Comprobación de Permisos de Archivos

En Linux, cada archivo y directorio tiene permisos asociados que determinan quién puede leerlos, escribirlos o ejecutarlos. En este paso, aprenderemos a verificar los permisos, específicamente si un archivo tiene permisos de lectura.

Primero, devolvamos nuestro archivo a su nombre original:
```
mv non_existent.txt test_file.txt
```
Crea un nuevo archivo de script llamado file_readable.sh:
```
touch file_readable.sh
```

Agrega el siguiente contenido al archivo:

#!/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

Este script utiliza la prueba -r, que verifica si el usuario actual tiene permiso para leer el archivo.

Guarda el archivo y sal del editor.
Otorga permisos de ejecución al script:
```
chmod +x file_readable.sh
```
Ejecuta el script:
```
./file_readable.sh
```
Deberías ver la salida: "You have read permission for test_file.txt"
Ahora, quitemos el permiso de lectura y ejecutemos el script de nuevo:
```
chmod -r test_file.txt
./file_readable.sh
```
Ahora deberías ver la salida: "You do not have read permission for test_file.txt"

chmod -r elimina los permisos de lectura del archivo.
Restaura el permiso de lectura:
```
chmod +r test_file.txt
```
Es importante restaurar los permisos para no dejar accidentalmente el archivo inaccesible.

Este script demuestra cómo inspeccionar los permisos de los archivos. Comprender y gestionar los permisos es fundamental para la seguridad del sistema y el correcto funcionamiento de los scripts.

Resumen

En esta práctica de laboratorio, has aprendido a realizar operaciones esenciales del sistema de archivos en la shell. Has creado scripts para verificar la existencia de archivos y directorios, así como para comprobar los permisos de acceso. Estas habilidades son fundamentales para trabajar en entornos Linux y constituyen la base para tareas de scripting más complejas.

Has practicado:

La comprensión de tu entorno de trabajo.
La creación y manipulación de archivos.
La escritura y ejecución de scripts de shell.
La comprobación de existencia de archivos y directorios.
La verificación de permisos de archivos.

Estos conocimientos serán valiosos a medida que continúes explorando sistemas Linux y desarrolles scripts más avanzados. Recuerda siempre verificar la existencia de archivos y directorios antes de operar con ellos para evitar errores. Asimismo, mantente atento a los permisos cuando trabajes con datos sensibles o archivos del sistema.

A medida que progreses, podrías explorar pruebas de archivos más avanzadas, aprender sobre otras estructuras de scripting como bucles y funciones, y practicar la combinación de estos conceptos para crear scripts más potentes y sofisticados.

Operaciones del Sistema de Archivos en Shell