sysinfo

Sysinfo

sysinfo é uma caixa usada para obter as informações de um sistema.

Oses suportados

Atualmente, ele suporta os seguintes sistemas operacionais (classificados em ordem alfabética):

• Android
• FreeBSD
• iOS
• Linux
• macos
• Raspberry Pi
• Windows

Você ainda pode usar sysinfo em oses não suportados, ele simplesmente não fará nada e sempre retornará valores vazios. Você pode verificar diretamente o seu programa se um sistema operacional for suportado verificando a constante [ IS_SUPPORTED_SYSTEM ].

A versão mínima do rustc é de 1,74 .

Uso

Se você deseja migrar de uma versão mais antiga, não hesite em dar uma olhada no Changelog e no Guia de Migração.

️ Antes de qualquer tentativa de ler as informações das diferentes estruturas, você precisa atualizá-las para obter informações atualizadas porque, para a maioria delas, elas funcionam no Diff entre o valor atual e o antigo.

É por isso que é muito melhor manter a mesma instância de [ System ] em vez de recriá -lo várias vezes.

Você tem um exemplo na pasta examples . Você pode executá -lo com cargo run --example simple .

Caso contrário, aqui está uma pequena amostra de código:

 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:?}" ) ;
}

Lembre-se de que, para ter algumas informações atualizadas, você precisa chamar o método refresh equivalente. Por exemplo, para o uso da CPU:

 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 ) ;
}

Por padrão, sysinfo usa vários threads. No entanto, isso pode aumentar o uso da memória em algumas plataformas (macOS, por exemplo). O comportamento pode ser desativado definindo default-features = false em Cargo.toml (que desativa o recurso de carga multithread ).

Boas práticas / dicas de desempenho

Na maioria das vezes, você não deseja todas as informações fornecidas pelo sysinfo , mas apenas um subconjunto. Nesse caso, é recomendável usar métodos refresh_specifics(...) apenas com o que você precisa ter um desempenho muito melhor.

Outros problemas encontrados com frequência: a menos que você saiba o que está fazendo, é quase o tempo todo melhor instanciar a estrutura System uma vez e usar essa instância por meio do seu programa. O motivo é que muitas informações precisam de uma medida anterior a ser calculada (o uso da CPU, por exemplo). Outro exemplo de por que é muito melhor: caso você queira listar todos os processos em execução, sysinfo precisa alocar toda a memória para a lista de estruturas de Process , que leva algum tempo na primeira execução.

Se o seu programa precisar usar muitos descritores de arquivos, é melhor você usar:

sysinfo :: set_open_files_limit ( 0 ) ;

Como sysinfo mantém vários descritores de arquivos abertos para ter um melhor desempenho em alguns alvos ao atualizar processos.

Correndo no Raspberry Pi

Será difícil construir no Raspberry Pi. Uma boa maneira é a construção cruzada e enviar o executável ao seu Raspberry Pi.

Primeiro instale a cadeia de ferramentas do ARM, por exemplo, no Ubuntu:

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

Em seguida, configure a carga para usar a cadeia de ferramentas correspondente:

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

Finalmente, cruzar compilar:

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

Linux no Subsistema Docker & Windows para Linux (WSL)

Os sistemas Virtual Linux, como os executados no Subsistema Docker e Windows para Linux (WSL), não recebem informações de hardware do host via /sys/class/hwmon ou /sys/class/thermal . Como tal, a consulta para componentes pode retornar resultados (ou resultados inesperados) ao usar esta biblioteca em sistemas virtuais.

Use em binários que funcionam dentro da caixa de areia/iOS ou iOS ou iOS

A Apple tem restrições sobre as quais as APIs podem ser vinculadas a binários que são distribuídos pela App Store. Por padrão, sysinfo não é compatível com essas restrições. Você pode usar o sinalizador de recursos apple-app-store para desativar os recursos proibidos da Apple. Isso também permite o recurso apple-sandbox . No caso de aplicativos usando a caixa de areia fora da App Store, o recurso apple-sandbox pode ser usado sozinho para evitar causar violações de políticas em tempo de execução.

Como funciona

Eu escrevi uma postagem no blog que você pode encontrar aqui, o que explica como sysinfo extrai informações sobre os diferentes sistemas.

Interface C.

É possível usar essa caixa diretamente de C. Dê uma olhada no Makefile e no arquivo examples/simple.c .

Para construir o exemplo C, basta executar:

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

Benchmarks

Você pode executar os benchmarks localmente com ferrugem todas as noites fazendo:

 > cargo bench

Doações

Se você aprecia meu trabalho e deseja me apoiar, pode fazê -lo com patrocinadores do Github ou com Patreon.