Interactuando con el Sistema Operativo en Rust: Archivos, Directorios y Procesos ⚙️

Rust, con su enfoque en la seguridad y el rendimiento, es una excelente opción para tareas de bajo nivel que requieren interacción directa con el sistema operativo. En este tutorial, profundizaremos en cómo Rust facilita la gestión de archivos, directorios y la ejecución de procesos externos, habilidades cruciales para cualquier aplicación de sistema o utilidad CLI.

🚀 Primeros Pasos: El Módulo std::fs para Gestión de Archivos y Directorios

El módulo std::fs de la biblioteca estándar de Rust proporciona todas las herramientas necesarias para trabajar con el sistema de archivos. Desde la creación y eliminación de archivos hasta la lectura y escritura de su contenido, std::fs te cubre.

📝 Creando y Escribiendo en Archivos

Para crear un nuevo archivo y escribir contenido en él, puedes usar File::create y los métodos de escritura proporcionados por std::io::Write. La mayoría de estas operaciones devuelven un Result, lo que te obliga a manejar posibles errores, una de las grandes fortalezas de Rust.

use std::fs::File;
use std::io::prelude::*;
use std::io::{self, BufWriter};

fn main() -> io::Result<()> {
    // Crear un nuevo archivo (o truncar si ya existe)
    let mut file = File::create("hola_mundo.txt")?;

    // Escribir una cadena en el archivo
    file.write_all(b"Hola, Rust!\n")?;
    file.write_all(b"Este es mi primer archivo.\n")?;

    // Cerrar el archivo explícitamente (opcional, se cierra al salir del scope)
    // drop(file);

    println!("Archivo 'hola_mundo.txt' creado y escrito con éxito.");

    // Usando BufWriter para escritura eficiente
    let file_buffered = File::create("salida_buffer.txt")?;
    let mut writer = BufWriter::new(file_buffered);

    for i in 0..10 {
        writeln!(writer, "Línea número {}", i)?;
    }
    writer.flush()?; // Asegurarse de que el buffer se vacíe en el archivo

    println!("Archivo 'salida_buffer.txt' creado y escrito con BufWriter.");

    Ok(())
}

📖 Leyendo Contenido de Archivos

Para leer archivos, File::open es el punto de partida. Puedes leer el contenido completo de una vez o línea por línea.

use std::fs::File;
use std::io::{self, BufReader};
use std::io::prelude::*;

fn main() -> io::Result<()> {
    // Leer todo el contenido de un archivo a una String
    let mut contents = String::new();
    File::open("hola_mundo.txt")?.read_to_string(&mut contents)?;
    println!("Contenido de 'hola_mundo.txt':\n{}", contents);

    // Leer un archivo línea por línea
    let file = File::open("salida_buffer.txt")?;
    let reader = BufReader::new(file);

    println!("Contenido de 'salida_buffer.txt' (línea por línea):");
    for (i, line) in reader.lines().enumerate() {
        println!("Línea {}: {}", i + 1, line?);
    }

    Ok(())
}

📂 Manipulando Directorios

Rust también facilita la creación, eliminación y listado de directorios. La estructura es similar a la gestión de archivos, con funciones específicas para directorios.

use std::fs;
use std::io;

fn main() -> io::Result<()> {
    let dir_name = "mi_directorio";
    let subdir_name = "mi_directorio/sub_directorio";

    // Crear un directorio
    fs::create_dir(dir_name)?;
    println!("Directorio '{}' creado.", dir_name);

    // Crear directorios recursivamente
    fs::create_dir_all(subdir_name)?;
    println!("Directorio y subdirectorios '{}' creados recursivamente.", subdir_name);

    // Listar contenido de un directorio
    println!("Contenido de '{}':", dir_name);
    for entry in fs::read_dir(dir_name)? {
        let entry = entry?;
        let path = entry.path();
        println!("- {}", path.display());
    }

    // Renombrar un archivo o directorio
    fs::rename(dir_name, "nuevo_nombre_dir")?;
    println!("Directorio '{}' renombrado a 'nuevo_nombre_dir'.", dir_name);

    // Eliminar un directorio vacío
    fs::remove_dir("nuevo_nombre_dir/sub_directorio")?;
    println!("Subdirectorio 'nuevo_nombre_dir/sub_directorio' eliminado.");

    // Eliminar un directorio no vacío (recursivamente)
    // ⚠️ ¡CUIDADO! Esto eliminará todo el contenido.
    fs::remove_dir_all("nuevo_nombre_dir")?;
    println!("Directorio 'nuevo_nombre_dir' eliminado recursivamente.");

    Ok(())
}

🛡️ Atributos y Metadatos de Archivos

Además de leer y escribir, a menudo necesitamos obtener información sobre los archivos, como su tamaño, permisos o la última fecha de modificación. El tipo fs::Metadata y fs::Permissions nos permiten acceder a esta información.

use std::fs;
use std::io;
use std::time::SystemTime;

fn main() -> io::Result<()> {
    // Asegurarse de que el archivo exista para el ejemplo
    fs::write("mi_archivo_info.txt", "Contenido de prueba.")?;

    let metadata = fs::metadata("mi_archivo_info.txt")?;

    println!("Información de 'mi_archivo_info.txt':");
    println!("- Es un directorio: {}", metadata.is_dir());
    println!("- Es un archivo: {}", metadata.is_file());
    println!("- Tamaño (bytes): {}", metadata.len());

    if let Ok(time) = metadata.modified() {
        println!("- Última modificación: {:?}", time);
    } else {
        println!("- No se pudo obtener la hora de última modificación.");
    }

    // Permisos (específicos del sistema operativo)
    let permissions = metadata.permissions();
    println!("- Permisos de solo lectura: {}", permissions.readonly());

    // Cambiar permisos (ejemplo: hacer solo lectura)
    let mut new_permissions = permissions;
    new_permissions.set_readonly(true);
    fs::set_permissions("mi_archivo_info.txt", new_permissions)?;
    println!("Permisos de 'mi_archivo_info.txt' establecidos a solo lectura.");

    let new_metadata = fs::metadata("mi_archivo_info.txt")?;
    println!("- ¿Ahora es solo lectura?: {}", new_metadata.permissions().readonly());

    // Limpiar
    fs::remove_file("mi_archivo_info.txt")?;

    Ok(())
}

⚡ Ejecutando Procesos Externos con std::process

Rust permite ejecutar comandos externos y capturar su salida, lo que es fundamental para scripts del sistema o para interactuar con otras herramientas. El módulo std::process y, en particular, el tipo Command son tus aliados aquí.

➡️ Ejecutando un Comando Simple

Para ejecutar un comando básico y esperar su finalización, puedes usar Command::new y spawn o output.

use std::process::Command;
use std::io;

fn main() -> io::Result<()> {
    // Ejecutar un comando simple y esperar su salida
    let output = Command::new("echo")
                         .arg("Hola desde un proceso externo!")
                         .output()?;

    // `output` devuelve un `Output` que contiene stdout, stderr y el código de salida.
    println!("Estado del comando: {}", output.status);
    println!("Salida estándar:\n{}", String::from_utf8_lossy(&output.stdout));
    eprintln!("Error estándar:\n{}", String::from_utf8_lossy(&output.stderr));

    // Verificar si el comando fue exitoso
    if output.status.success() {
        println!("Comando ejecutado con éxito.");
    } else {
        eprintln!("El comando falló.");
    }

    // Ejemplo de comando que probablemente falle para ver stderr
    let bad_command_output = Command::new("non_existent_command")
                                     .output();
    match bad_command_output {
        Ok(output) => {
            eprintln!("Comando fallido (salida): {}", String::from_utf8_lossy(&output.stderr));
        }
        Err(e) => {
            eprintln!("Error al intentar ejecutar comando inexistente: {}", e);
        }
    }

    Ok(())
}

📊 Canalizando Entrada/Salida a Procesos

Command te permite controlar las tuberías (pipes) de entrada y salida estándar del proceso hijo. Puedes redirigir la entrada estándar desde una cadena o un archivo, y capturar o redirigir la salida.

use std::process::{Command, Stdio};
use std::io::{self, Write};

fn main() -> io::Result<()> {
    // Redirigir la entrada estándar desde una cadena y capturar la salida
    let mut child = Command::new("grep")
                            .arg("palabra")
                            .stdin(Stdio::piped())
                            .stdout(Stdio::piped())
                            .spawn()?;

    if let Some(mut stdin) = child.stdin.take() {
        stdin.write_all(b"Esto es una frase con la palabra clave.\n")?;
        stdin.write_all(b"Y otra frase sin la clave.\n")?;
        stdin.write_all(b"Una ultima palabra mas.\n")?;
    }

    let output = child.wait_with_output()?; // Esperar a que el proceso termine y capturar salida

    println!("grep status: {}", output.status);
    println!("grep stdout:\n{}", String::from_utf8_lossy(&output.stdout));

    // Redirigir la salida estándar a un archivo
    let output_file = File::create("grep_output.txt")?;
    Command::new("grep")
            .arg("Rust")
            .arg("hola_mundo.txt") // Asumiendo que existe de un ejemplo anterior
            .stdout(Stdio::from(output_file))
            .spawn()?;
    
    println!("Salida de grep redirigida a 'grep_output.txt'.");

    Ok(())
}

⏱️ Controlando Procesos de Larga Duración

Para procesos que se ejecutan en segundo plano o que necesitas controlar más allá de simplemente esperar su finalización, Child te da acceso a métodos como kill, wait o try_wait.

use std::process::{Command, Stdio};
use std::thread;
use std::time::Duration;
use std::io::{self, BufReader, BufRead};

fn main() -> io::Result<()> {
    // Ejemplo de un proceso de larga duración (ej. 'ping' o 'yes')
    // Usaremos un comando que simula un trabajo continuo
    // En sistemas Unix/Linux: `yes` o `sleep 5`
    // En Windows: `timeout /t 5` o un script PowerShell que haga un bucle

    #[cfg(target_os = "windows")]
    let mut child = Command::new("cmd")
                            .arg("/C")
                            .arg("timeout /t 5") // Espera 5 segundos
                            .stdout(Stdio::piped())
                            .spawn()?;

    #[cfg(not(target_os = "windows"))]
    let mut child = Command::new("sleep")
                            .arg("5")
                            .stdout(Stdio::piped())
                            .spawn()?;
    
    println!("Proceso hijo iniciado. PID: {:?}", child.id());

    // Leer la salida del proceso hijo en tiempo real (si tiene)
    if let Some(stdout) = child.stdout.take() {
        let reader = BufReader::new(stdout);
        for line in reader.lines() {
            println!("Proceso hijo dice: {}", line?);
        }
    }

    // Esperar un tiempo antes de terminarlo (o esperar que termine solo)
    thread::sleep(Duration::from_secs(2));
    
    // Comprobar si el proceso sigue vivo
    if let Ok(Some(status)) = child.try_wait() {
        println!("Proceso ya terminó con estado: {}", status);
    } else {
        println!("Proceso aún en ejecución. Intentando terminarlo.");
        child.kill()?;
        println!("Proceso terminado.");
    }

    // Esperar al proceso si aún no ha terminado
    let status = child.wait()?;
    println!("Estado final del proceso: {}", status);

    Ok(())
}

🗺️ Rutas y Plataformas con std::path

Trabajar con rutas de archivos y directorios de manera agnóstica a la plataforma es vital. El módulo std::path proporciona los tipos Path y PathBuf para manejar esto de forma segura y consistente.

🧱 Construyendo y Descomponiendo Rutas

PathBuf es la versión mutable y poseedora de Path y es útil para construir rutas dinámicamente. Path es una vista inmutable y presta (similar a str vs String).

use std::path::{Path, PathBuf};

fn main() {
    // Crear una ruta a partir de una cadena
    let path = Path::new("/usr/local/bin/myapp");

    println!("Ruta completa: {}", path.display());
    println!("Componente raíz: {:?}", path.parent());
    println!("Nombre del archivo (con extensión): {:?}", path.file_name());
    println!("Extensión: {:?}", path.extension());
    println!("Nombre del archivo (sin extensión): {:?}", path.file_stem());

    // Construir una ruta dinámicamente con PathBuf
    let mut current_dir = PathBuf::from("."); // '.' representa el directorio actual
    current_dir.push("data"); // Añade 'data' a la ruta: './data'
    current_dir.push("config.toml"); // Añade 'config.toml': './data/config.toml'

    println!("Ruta construida: {}", current_dir.display());

    // Unir componentes de forma segura
    let base = PathBuf::from("/home/user");
    let file = PathBuf::from("documentos/reporte.pdf");
    let full_path = base.join(file);
    println!("Ruta unida: {}", full_path.display());

    // Convertir a una cadena (puede fallar si la ruta no es UTF-8 válido)
    match full_path.to_str() {
        Some(s) => println!("Ruta como string: {}", s),
        None => println!("La ruta contiene caracteres no UTF-8."),
    }
}

🌍 Diferencias entre Plataformas

Rust abstrae muchas de las diferencias entre sistemas operativos para las rutas, pero algunas peculiaridades aún existen.

Rust se encarga de usar el separador correcto para PathBuf::push y Path::join en tiempo de ejecución.

✅ Conclusión

Interactuar con el sistema operativo es una parte fundamental del desarrollo de muchas aplicaciones, desde utilidades de línea de comandos hasta servicios de fondo. Rust, con sus módulos std::fs, std::process y std::path, proporciona un conjunto de herramientas potente, seguro y ergonómico para estas tareas.

Has aprendido a:

• 📂 Crear, leer y escribir archivos con std::fs.
• 📁 Gestionar directorios: crear, eliminar y listar contenido.
• 🔍 Obtener y modificar metadatos de archivos.
• ⚡ Ejecutar comandos externos y controlar procesos con std::process.
• 🗺️ Manejar rutas de archivos de manera agnóstica a la plataforma con std::path.

Con estas habilidades, estás bien equipado para desarrollar aplicaciones Rust que se integren profundamente con el entorno del sistema operativo. ¡Continúa experimentando y construyendo!