Hoe een commando-line programma te ontwikkelen voor bestandscounts in Rust

Het ontwikkelen van een programma in Rust om basisbestandstatistieken te verzamelen zoals regel-, woord-, byte- en tekenaantallen is een nuttige oefening in het gebruik van de standaardbibliotheek en het werken met commandoregelargumenten. Een veelgebruikte tool in Unix-achtige systemen is het wc-commando (word count), waarmee gebruikers snel de statistieken van een bestand kunnen verkrijgen. Dit artikel beschrijft hoe je een vergelijkbare versie van dit programma kunt bouwen in Rust, met ondersteuning voor meerdere invoerbestanden, foutafhandeling en dynamische commandoregelopties.

Argumenten en Opties

Een essentieel onderdeel van dit programma is de mogelijkheid om verschillende argumenten op te nemen die bepalen welke statistieken worden weergegeven. De belangrijkste opties zijn:

• -c of --bytes: toon het aantal bytes in de ingevoerde bestanden.

• -m of --chars: toon het aantal tekens.

• -l of --lines: toon het aantal regels.

• -w of --words: toon het aantal woorden.

• -L of --max-line-length: toon de lengte van de langste regel.

Structuur van het Programma

Het eerste element in het proces is het instellen van de benodigde commandoregelargumenten. In Rust kan dit eenvoudig worden bereikt door de clap bibliotheek te gebruiken, die een robuuste manier biedt om argumenten te verwerken. Dit kan bijvoorbeeld op de volgende manier worden gedaan:

rust
Copy code
use clap::{Arg, Command};

fn get_args() -> Args {
    let matches = Command::new("wcr")
        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust versie van `wc`")
        .arg(Arg::new("files")
            .value_name("FILE")
            .help("Invoerbestand(en)")
            .default_value("-")
            .num_args(0..))
        .arg(Arg::new("lines")
            .short('l')
            .long("lines")
            .action(ArgAction::SetTrue)
            .help("Toon het aantal regels"))
        .arg(Arg::new("words")
            .short('w')
            .long("words")
            .action(ArgAction::SetTrue)
            .help("Toon het aantal woorden"))
        .arg(Arg::new("bytes")
            .short('c')
            .long("bytes")
            .action(ArgAction::SetTrue)
            .help("Toon het aantal bytes"))
        .arg(Arg::new("chars")
            .short('m')
            .long("chars")
            .action(ArgAction::SetTrue)
            .help("Toon het aantal tekens")
            .conflicts_with("bytes"))
        .get_matches();
    Args {
        files: matches.get_many("files").unwrap().cloned().collect(),
        lines: matches.get_flag("lines"),
        words: matches.get_flag("words"),
        bytes: matches.get_flag("bytes"),
        chars: matches.get_flag("chars"),
    }
}

Foutafhandeling

Een van de belangrijke aspecten van het programma is het correct afhandelen van fouten, zoals wanneer een bestand niet bestaat. Als een bestand niet kan worden geopend, moet een foutmelding naar de standaardfout (STDERR) worden gestuurd. Dit kan eenvoudig worden gedaan met de ingebouwde foutafhandelingsmechanismen van Rust:

bash
Copy code
wc tests/inputs/fox.txt blargh

wc: blargh: open: No such file or directory

Als een bestand niet bestaat, wordt een foutmelding weergegeven, maar het programma moet doorgaan met de verwerking van andere bestanden. Dit kan worden geverifieerd door de foutuitvoer naar een bestand om te leiden:

bash
Copy code
wc tests/inputs/fox.txt blargh 2>err
cat err
wc: blargh: open: No such file or directory

Verwerken van Meerdere Bestanden

bash
Copy code
$ wc tests/inputs/*.txt
4      29     177 tests/inputs/atlamal.txt
0       0       0 tests/inputs/empty.txt
1       9      48 tests/inputs/fox.txt
total

Alternatieven voor het Gebruiken van de CLI

Afhankelijk van de voorkeur van de gebruiker kan de clap-bibliotheek zowel de "derive" als de "builder" patroon ondersteunen voor het verwerken van de argumenten. Het "builder" patroon is handiger voor complexere configuraties, terwijl het "derive" patroon eenvoudiger en leesbaarder is voor kleinere programma's. Het gebruik van de Args structuur kan beide patronen ondersteunen, afhankelijk van de complexiteit van het programma.

Verdere Aanbevelingen

Naast de basismogelijkheden die hierboven zijn beschreven, kunnen er ook enkele aanvullende functionaliteiten worden overwogen, zoals:

• Het ondersteunen van bestandswildcards (bijvoorbeeld *.txt), zodat gebruikers meerdere bestanden tegelijk kunnen verwerken zonder ze expliciet op te sommen.

• Het bieden van gedetailleerdere foutmeldingen wanneer bestanden niet toegankelijk zijn, bijvoorbeeld door aan te geven of het bestand niet bestaat of dat er een machtigingsprobleem is.

• Het bieden van meer gedetailleerde uitvoeropties, zoals het weergeven van de langste regel met de bijbehorende lengte (optie --max-line-length).

Hoe structuren en tijdelijke bestanden correct te gebruiken in Rust-tests

In het proces van het ontwikkelen van een softwaretoepassing is het essentieel om robuuste tests te schrijven die zowel de functionaliteit van de code controleren als de stabiliteit waarborgen. In dit kader speelt de taal Rust, met zijn rijke type- en levensduurbeheersysteem, een cruciale rol bij het beheren van invoer- en uitvoerbestanden tijdens het testen. In dit hoofdstuk wordt besproken hoe je Rust-structuren en tijdelijke bestanden effectief kunt gebruiken voor het testen van programma’s, met specifieke nadruk op levensduurbeheer, de werking van het bestandssysteem, en de manier waarop je gegevens valideert.

Een belangrijk concept in Rust is het gebruik van ‘lifetimes’, die aangeven hoe lang een bepaalde waarde in het geheugen geldig blijft. Dit wordt aangeduid met het levensduur-symbool 'static, wat betekent dat de waarde geldig is gedurende de gehele levensduur van het programma. Het correct gebruik van levensduurannotaties is cruciaal, vooral wanneer je structuren met &str-waarden definieert. Dit stelt de compiler in staat om te begrijpen hoe lang bepaalde gegevens beschikbaar blijven voor uitleen (borrowing) binnen het programma. Het gebruik van static zorgt ervoor dat de gegevens gedurende de gehele levensduur van het programma blijven bestaan, waardoor veelvoorkomende compilatiefouten, zoals ontbrekende levensduurparameters, kunnen worden voorkomen.

Bijvoorbeeld, het definiëren van een constante struct, zoals:

rust
Copy code
const PRG: &str = "uniqr";

const EMPTY: Test = Test {
    input: "tests/inputs/empty.txt",
    out: "tests/inputs/empty.txt.out",
    out_count: "tests/inputs/empty.txt.c.out",
};

In dit geval wordt EMPTY gedefinieerd als een Test-struct die invoer-, uitvoer- en uitvoertelbestanden specificeert. Dit geeft aan dat de bestanden die voor de test worden gebruikt, vast staan en beschikbaar blijven gedurende de volledige levensduur van het programma.

rust
Copy code
fn run(test: &Test) -> Result<()> {
    let expected = fs::read_to_string(test.out)?;
    let output = Command::cargo_bin(PRG)?
        .arg(test.input)
        .output()
        .expect("fail");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("invalid UTF-8");
    assert_eq!(stdout, expected);
    Ok(())
}

Deze test verifieert of het programma de verwachte uitvoer produceert wanneer het wordt uitgevoerd met een bepaald invoerbestand. Dit gebeurt door de standaarduitvoer van het programma te vergelijken met de inhoud van het verwachte uitvoerbestand.

rust
Copy code
fn run_count(test: &Test) -> Result<()> {
    let expected = fs::read_to_string(test.out_count)?;
    let output = Command::cargo_bin(PRG)?
        .args([test.input, "-c"])
        .output()
        .expect("fail");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("invalid UTF-8");
    assert_eq!(stdout, expected);
    Ok(())
}

Wanneer een bestand via STDIN wordt ingevoerd, kan de test worden aangepast om invoer via de standaardinvoer te lezen en de verwachte uitvoer te vergelijken:

rust
Copy code
fn run_stdin(test: &Test) -> Result<()> {

    let input = fs::read_to_string(test.input)?;
    let expected = fs::read_to_string(test.out)?;
    let output = Command::cargo_bin(PRG)?
        .write_stdin(input)
        .output()
        .expect("fail");
    assert!(output.status.success());
    let stdout = String::from_utf8(output.stdout).expect("invalid UTF-8");
    assert_eq!(stdout, expected);
    Ok(())
}

Hierbij wordt de inhoud van het invoerbestand gelezen, doorgegeven via STDIN, en de uitvoer wordt vergeleken met het verwachte resultaat.

Om een testsuite goed te laten werken, moeten we ook omgaan met tijdelijke bestanden. Dit is belangrijk wanneer meerdere tests in parallel worden uitgevoerd, wat kan leiden tot het overschrijven van bestanden als dezelfde naam wordt gebruikt. In dergelijke gevallen kunnen we tempfile::NamedTempFile gebruiken om tijdelijke bestanden met unieke namen te genereren, die automatisch worden verwijderd na gebruik:

rust
Copy code
fn run_outfile(test: &Test) -> Result<()> {

    let expected = fs::read_to_string(test.out)?;
    let outfile = NamedTempFile::new()?;
    let outpath = &outfile.path().to_str().unwrap();
    Command::cargo_bin(PRG)?
        .args(&[test.input, outpath])
        .assert()
        .success()
        .stdout("");
    let contents = fs::read_to_string(&outpath)?;
    assert_eq!(&expected, &contents);
    Ok(())
}

Het genereren van tijdelijke bestanden voorkomt conflicten tussen gelijktijdige testuitvoeringen en garandeert dat elke test in isolatie kan worden uitgevoerd zonder dat de uitvoer wordt beïnvloed door andere tests.

rust
Copy code
fn run(args: Args) -> Result<()> {

    let mut file = open(&args.in_file)

        .map_err(|e| anyhow!("{}: {e}", args.in_file))?;
    let mut line = String::new();
    loop {

        let bytes = file.read_line(&mut line)?;

        if bytes == 0 {
            break;
        }
        print!("{line}");
        line.clear();
    }
    Ok(())
}

Het belangrijkste is dat je zorgt voor de juiste lezing van bestanden (zowel via STDIN als via bestandsnamen), het effectief verwerken van invoer en uitvoer, en het correct beheren van tijdelijke bestanden om testisolatie te waarborgen.

De toepassing van deze technieken is een fundamenteel onderdeel van het ontwikkelen van betrouwbare software en kan je helpen om robuuste en herhaalbare tests te schrijven, wat essentieel is voor het waarborgen van de kwaliteit van je programma’s op lange termijn.

Hoe werken bestandspermissies in Linux en wat betekenen ze voor de programmeur?

Bestandspermissies in Linux kunnen verwarrend zijn voor de beginnende gebruiker, maar ze zijn essentieel voor de veiligheid en het beheer van bestanden in een systeem. In de kern gaat het om wie wat mag doen met een bestand of map: lezen, schrijven of uitvoeren. Dit wordt vaak weergegeven in octale notatie, een gestandaardiseerd systeem dat de staat van drie verschillende permissies vastlegt: lezen, schrijven en uitvoeren. Elk van deze permissies wordt gepresenteerd als een bit in een getal, en door deze getallen te combineren, kan een beheerder het juiste niveau van toegang tot bestanden en mappen vastleggen.

In de octale notatie heeft elke bitpositie een specifieke betekenis: de meest significante bit (de 4-positie) vertegenwoordigt leesrechten, de 2-positie betekent schrijfpermissies en de minst significante bit (de 1-positie) staat voor uitvoeringsrechten. Deze bitjes worden gecombineerd om de uiteindelijke permissies voor een bestand te bepalen. De octale getallen worden vaak weergegeven als drie cijfers, waarbij elk cijfer staat voor de permissies voor de eigenaar, de groep en anderen.

Bijvoorbeeld, de permissies van 775 geven aan dat zowel de eigenaar als de groep lees-, schrijf- en uitvoeringsrechten hebben, terwijl anderen alleen lees- en uitvoeringsrechten hebben. Dit is handig als je wilt dat andere gebruikers een programma kunnen uitvoeren, maar alleen de eigenaar of groep het bestand kunnen bewerken. Een veelgebruikte permissie voor gevoelige data, zoals SSH-sleutels, is 600. Dit betekent dat alleen de eigenaar het bestand kan lezen en schrijven, terwijl anderen geen toegang hebben.

In Linux wordt deze notatie vaak gebruikt in combinatie met de chmod-opdracht, die wordt gebruikt om bestandspermissies in te stellen. Bijvoorbeeld, de opdracht chmod 775 zou de juiste rechten instellen voor zowel de eigenaar als de groep, maar alleen lees- en uitvoerrechten voor anderen. Voor gevoelige gegevens zoals SSH-sleutels wordt echter vaak de permissie 600 gebruikt, wat betekent dat alleen de eigenaar toegang heeft.

Een ander concept dat belangrijk is om te begrijpen bij het werken met bestandspermissies in Linux is het gebruik van bitwise operaties, zoals de AND-operator (&). Deze bewerking wordt gebruikt om te testen of een specifieke permissie is ingesteld voor een bestand. Bijvoorbeeld, als je de bitwise AND uitvoert op de waarden 0o700 en 0o200, dan zou het resultaat 0o200 zijn, wat betekent dat de schrijfpermissie is ingesteld. Als de AND-operator echter wordt uitgevoerd op 0o400 en 0o200, dan zou het resultaat 0o000 zijn, omdat er geen overeenkomstige bits zijn die op 1 zijn ingesteld.

Naast het begrijpen van de permissies zelf, is het ook belangrijk om een goed begrip te hebben van hoe deze permissies worden weergegeven in de bestandsuitvoer van commando’s zoals ls -l. Het uitvoerformaat toont de lees-, schrijf- en uitvoeringsrechten voor de eigenaar, de groep en anderen. Dit helpt niet alleen bij het beheren van bestanden, maar ook bij het schrijven van programma’s die bestanden moeten lezen, schrijven of uitvoeren op basis van deze permissies.

Er zijn verschillende functies die kunnen worden gebruikt om bestandspermissies te lezen en weer te geven. Bijvoorbeeld, de functie format_mode kan worden gebruikt om de octale representatie van de permissies om te zetten in een leesbare tekenreeks. Het accepteert een waarde die de bestandsmodus in octale notatie weergeeft en retourneert een string zoals "rwxr-xr-x". Dit helpt programmeurs om de permissies van een bestand te begrijpen zonder zich zorgen te maken over de details van de octale notatie.

Een ander belangrijk aspect is het testen van deze functies om ervoor te zorgen dat de juiste permissies worden weergegeven. Door een eenheidstest toe te voegen, kunnen programmeurs de functies valideren en ervoor zorgen dat ze het verwachte resultaat opleveren. Bijvoorbeeld, een test zou kunnen controleren of de functie format_mode(0o755) de juiste uitvoer "rwxr-xr-x" geeft, wat betekent dat de eigenaar lees-, schrijf- en uitvoeringsrechten heeft, terwijl de groep en anderen alleen lees- en uitvoeringsrechten hebben.

Hoewel de bestandspermissies zelf relatief eenvoudig lijken, kunnen ze in de praktijk complex worden. Dit komt doordat bestandspermissies niet alleen bepalen wie toegang heeft tot een bestand, maar ook hoe die toegang wordt gecontroleerd, toegepast en beheerd. In een programma is het belangrijk om deze permissies op de juiste manier te lezen en te gebruiken om ervoor te zorgen dat een bestand op een veilige en efficiënte manier kan worden gebruikt.

Wat is verder belangrijk?

Wanneer je werkt met bestandspermissies, moet je altijd rekening houden met de veiligheid en de privacy van je systeem. Bestandspermissies spelen een cruciale rol bij het beperken van ongeautoriseerde toegang tot gevoelige gegevens. Het is bijvoorbeeld raadzaam om gevoelige bestanden altijd de permissie 600 of zelfs 400 te geven, zodat alleen de eigenaar toegang heeft. Dit voorkomt dat andere gebruikers per ongeluk toegang krijgen tot vertrouwelijke informatie.

Het gebruik van de juiste bestandspermissies kan ook helpen om de prestaties van je systeem te optimaliseren. Onjuiste permissies kunnen leiden tot overbodige beveiligingscontroles of inefficiënte toegangspaden, wat de snelheid en efficiëntie van besturingssystemen kan verminderen. Daarom is het essentieel om deze goed in te stellen bij het ontwikkelen van software en het beheren van servers.