sysinfo

sysinfo

sysinfo est une caisse utilisée pour obtenir les informations d'un système.

Os soutenu

Il prend actuellement en charge les OSO suivantes (tri par ordre alphabétique):

• Androïde
• FreeBSD
• ios
• Linux
• macos
• Raspberry Pi
• Fenêtre

Vous pouvez toujours utiliser sysinfo sur des OSE non soutenus, il ne fera rien et renvoie toujours des valeurs vides. Vous pouvez vérifier directement votre programme si un système d'exploitation est pris en charge en vérifiant la constante [ IS_SUPPORTED_SYSTEM ].

La version minimale soutenue de rustc est de 1,74 .

Usage

Si vous souhaitez migrer à partir d'une version plus ancienne, n'hésitez pas à jeter un œil au Changelog et au guide de migration.

️ Avant toute tentative de lire les informations des différentes structures, vous devez les mettre à jour pour obtenir des informations à jour, car pour la plupart d'entre elles, cela fonctionne sur Diff entre la valeur actuelle et l'ancienne.

C'est pourquoi, il vaut mieux garder le même exemple de [ System ] au lieu de le recréer plusieurs fois.

Vous avez un exemple dans le dossier examples . Vous pouvez l'exécuter avec cargo run --example simple .

Sinon, voici un petit exemple de code:

 use sysinfo :: {
    Components , Disks , Networks , System ,
} ;

// Please note that we use "new_all" to ensure that all lists of
// CPUs and processes are filled!
let mut sys = System :: new_all ( ) ;

// First we update all information of our `System` struct.
sys . refresh_all ( ) ;

println ! ( "=> system:" ) ;
// RAM and swap information:
println ! ( "total memory: {} bytes" , sys . total_memory ( ) ) ;
println ! ( "used memory : {} bytes" , sys . used_memory ( ) ) ;
println ! ( "total swap  : {} bytes" , sys . total_swap ( ) ) ;
println ! ( "used swap   : {} bytes" , sys . used_swap ( ) ) ;

// Display system information:
println ! ( "System name:             {:?}" , System :: name ( ) ) ;
println ! ( "System kernel version:   {:?}" , System :: kernel_version ( ) ) ;
println ! ( "System OS version:       {:?}" , System :: os_version ( ) ) ;
println ! ( "System host name:        {:?}" , System :: host_name ( ) ) ;

// Number of CPUs:
println ! ( "NB CPUs: {}" , sys . cpus ( ) . len ( ) ) ;

// Display processes ID, name na disk usage:
for ( pid , process ) in sys . processes ( ) {
    println ! ( "[{pid}] {:?} {:?}" , process . name ( ) , process . disk_usage ( ) ) ;
}

// We display all disks' information:
println ! ( "=> disks:" ) ;
let disks = Disks :: new_with_refreshed_list ( ) ;
for disk in & disks {
    println ! ( "{disk:?}" ) ;
}

// Network interfaces name, total data received and total data transmitted:
let networks = Networks :: new_with_refreshed_list ( ) ;
println ! ( "=> networks:" ) ;
for ( interface_name , data ) in & networks {
    println ! (
        "{interface_name}: {} B (down) / {} B (up)" ,
        data . total_received ( ) ,
        data . total_transmitted ( ) ,
    ) ;
    // If you want the amount of data received/transmitted since last call
    // to `Networks::refresh`, use `received`/`transmitted`.
}

// Components temperature:
let components = Components :: new_with_refreshed_list ( ) ;
println ! ( "=> components:" ) ;
for component in & components {
    println ! ( "{component:?}" ) ;
}

N'oubliez pas que pour avoir des informations à jour, vous devez appeler la méthode refresh équivalente. Par exemple, pour l'utilisation du processeur:

 use sysinfo :: System ;

let mut sys = System :: new ( ) ;

loop {
    sys . refresh_cpu_usage ( ) ; // Refreshing CPU usage.
    for cpu in sys . cpus ( ) {
        print ! ( "{}% " , cpu . cpu_usage ( ) ) ;
    }
    // Sleeping to let time for the system to run for long
    // enough to have useful information.
    std :: thread :: sleep ( sysinfo :: MINIMUM_CPU_UPDATE_INTERVAL ) ;
}

Par défaut, sysinfo utilise plusieurs threads. Cependant, cela peut augmenter l'utilisation de la mémoire sur certaines plates-formes (macOS par exemple). Le comportement peut être désactivé en définissant default-features = false dans Cargo.toml (qui désactive la fonction de cargo multithread ).

Conseils de bonnes pratiques / performances

La plupart du temps, vous ne voulez pas toutes les informations fournies par sysinfo mais juste un sous-ensemble. Dans ce cas, il est recommandé d'utiliser des méthodes refresh_specifics(...) avec seulement ce dont vous avez besoin pour avoir de bien meilleures performances.

Un autre problème fréquemment rencontré: à moins que vous ne sachiez ce que vous faites, il vaut presque tout le temps d'instancier la structure System une fois et d'utiliser cette seule instance via votre programme. La raison en est que beaucoup d'informations nécessitent une mesure précédente à calculer (l'utilisation du processeur par exemple). Un autre exemple pourquoi c'est beaucoup mieux: au cas où vous souhaitez répertorier tous les processus en cours d'exécution, sysinfo doit allouer toute la mémoire à la liste des structures de Process , ce qui prend un certain temps lors de la première exécution.

Si votre programme doit utiliser beaucoup de descripteurs de fichiers, vous feriez mieux d'utiliser:

sysinfo :: set_open_files_limit ( 0 ) ;

Comme sysinfo garde un certain nombre de descripteurs de fichiers ouverts pour avoir de meilleures performances sur certaines cibles lors des processus rafraîchissants.

Courir sur Raspberry Pi

Il sera difficile de construire sur Raspberry Pi. Une bonne voie consiste à construir, puis à envoyer l'exécutable à votre Raspberry Pi.

Installez d'abord la chaîne d'outils du bras, par exemple sur Ubuntu:

 > sudo apt-get install gcc-multilib-arm-linux-gnueabihf

Configurez ensuite la cargaison pour utiliser la chaîne d'outils correspondante:

cat << EOF > ~/.cargo/config
[target.armv7-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc"
EOF

Enfin, compilation croisée:

rustup target add armv7-unknown-linux-gnueabihf
cargo build --target=armv7-unknown-linux-gnueabihf

Sous-système Linux sur Docker & Windows pour Linux (WSL)

Les systèmes Virtual Linux, tels que ceux exécutés via Docker et Sous-système Windows pour Linux (WSL), ne reçoivent pas d'informations matérielles hôtes via /sys/class/hwmon ou /sys/class/thermal . En tant que tel, l'interrogation pour les composants ne peut renvoyer aucun résultat (ou des résultats inattendus) lors de l'utilisation de cette bibliothèque sur des systèmes virtuels.

Utiliser dans des binaires coulant à l'intérieur du macOS ou du sandbox / magasins iOS

Apple a des restrictions quant aux API peut être liée à des binaires distribués via l'App Store. Par défaut, sysinfo n'est pas compatible avec ces restrictions. Vous pouvez utiliser l'indicateur de fonctionnalité apple-app-store pour désactiver les fonctionnalités interdites Apple. Cela permet également la fonctionnalité apple-sandbox . Dans le cas des applications utilisant le bac à sable à l'extérieur de l'App Store, la fonctionnalité apple-sandbox peut être utilisée seule pour éviter de provoquer des violations de politique lors de l'exécution.

Comment ça marche

J'ai écrit un article de blog que vous pouvez trouver ici qui explique comment sysinfo extrait des informations sur les différents systèmes.

Interface C

Il est possible d'utiliser cette caisse directement à partir de C. Jetez un œil au fichier Makefile et aux examples/simple.c .

Pour construire l'exemple C, il suffit de courir:

 > make
> ./simple
# If needed:
> LD_LIBRARY_PATH=target/debug/ ./simple

Repères

Vous pouvez exécuter les repères localement avec rouille en faisant:

 > cargo bench

Dons

Si vous appréciez mon travail et que vous souhaitez me soutenir, vous pouvez le faire avec les sponsors GitHub ou avec Patreon.