No Rust, o módulo std::os fornece uma abstração sobre a funcionalidade do sistema operacional. Ele nos permite interagir com o sistema operacional subjacente para trabalhar com as variáveis de ambiente, operações do sistema de arquivos, gerenciamento de processos e muito mais.
Neste exemplo, abordaremos algumas operações fundamentais que você pode executar no Unix usando o módulo Rust std::os.
É bom lembrar que este é um módulo extenso e contém muitos tipos e funções para várias operações relacionadas ao Unix. Portanto, considere a documentação para referência nos processos correspondentes.
SO Rust no Linux
No Linux, podemos acessar as funções e tipos específicos do Unix que são fornecidos pelo módulo std::os::unix, um submódulo do módulo std::os no Rust.
Este módulo faz parte da biblioteca padrão Rust e, portanto, não requer a instalação de nenhuma caixa externa ou dependências.
Vamos cobrir algumas APIs e operações básicas que podemos realizar em um sistema Linux a partir deste módulo.
Acessando as Variáveis de Ambiente
Podemos acessar as variáveis de ambiente usando o módulo std::env. Por exemplo, std::env::var(“PATH”) recupera o valor da variável de ambiente PATH.
Considere o seguinte programa de exemplo:
usar std::env;use std::ffi::OsString;
mão fn ( ) {
// Acessar uma variável de ambiente específica
se deixar OK ( valor ) = ambiente::var ( 'WAYLAND_DISPLAY' ) {
println ! ( 'WAYLAND_DISPLAY={}' , valor ) ;
}
// Iterar sobre todas as variáveis de ambiente
para ( valor chave ) em env::wars_us ( ) {
deixar key_string = key.to_string_lossy ( ) ;
deixar value_string = value.to_string_lossy ( ) ;
println ! ( '{}:{}' , string_chave, string_valor ) ;
}
// Acessar uma variável de ambiente específica como um ` OsString `
se deixar Alguns ( valor ) = env::var_us ( 'HOSTTYPE' ) {
// Converter ` OsString ` para um ` Corda ` se necessário
se deixar Alguns ( value_str ) = valor.to_str ( ) {
println ! ( 'HOSTTYPE={}' , value_str ) ;
}
}
}
No exemplo dado, começamos importando os módulos necessários. Neste caso, estamos interessados no std::env e no std::ff::OsString.
Para acessar uma determinada variável de ambiente, podemos utilizar a função env::var e passar o nome do valor que desejamos buscar. Nesse caso, obtemos o valor da variável WAYLAND_DISPLAY.
A função retorna o valor da variável como um tipo de resultado.
Também podemos iterar sobre todas as variáveis de ambiente usando a função env::vars_os. Isso retorna um iterador com os pares chave-valor das variáveis de ambiente. É bom observar que os valores são retornados como um tipo OsString. Podemos então convertê-los em valores de string usando a função to_string_lossy.
Também podemos acessar as variáveis de ambiente específicas usando a função env::var_os. Isso deve retornar um tipo
A saída resultante é a seguinte:
WAYLAND_DISPLAY =wayland- 0HOSTTYPE =x86_64
Operações FS usando o módulo OS
Como você pode imaginar, o módulo do sistema operacional fornece várias funções e métodos para executar as operações relacionadas ao sistema de arquivos.
Pegue o seguinte programa que demonstra as várias operações que podemos realizar usando o módulo std::os no Linux:
usar padrão::fs;mão fn ( ) {
// Leia um arquivo
se deixar OK ( conteúdo ) = fs::read_to_string ( '/home/debian/.bashrc' ) {
println ! ( 'bashrc: {}' , conteúdo ) ;
}
// Criar um novo diretório
se deixar Errar ( errar ) = fs::create_dir ( '/home/debian/new_dir' ) {
eprintln ! ( 'Falha ao criar diretório: {}' , errar ) ;
}
// Remover um arquivo
se deixar Errar ( errar ) = fs::remove_file ( '/home/debian/remove_me.txt' ) {
eprintln ! ( 'Falha ao remover arquivo: {}' , errar ) ;
}
}
No exemplo dado, demonstramos como podemos ler o conteúdo de um arquivo usando o método fs::read_to_string(). O método pega o caminho para o arquivo de destino e retorna o conteúdo do arquivo como uma string.
Também podemos criar um novo diretório usando a função fs::create_dir() e passando o caminho para o diretório de destino como parâmetro.
Por fim, podemos remover um arquivo específico usando a função fs::remove_file() e passar o arquivo de destino como parâmetro.
OBSERVAÇÃO: Os exemplos fornecidos são alguns exemplos básicos de como executar as operações do sistema de arquivos no Linux usando o módulo std::fs. Rust fornece uma coleção abrangente de métodos e funções que são demonstradas aqui. Consulte a documentação para saber mais.
Gerenciamento de processos usando o módulo OS
Como você pode imaginar, o módulo do sistema operacional fornece submódulos e recursos para trabalhar com processos no sistema.
Pegue o seguinte código de exemplo:
use padrão::processo:: { Comando, saída } ;mão fn ( ) {
// executar o ls comando
deixar saída = Comando::novo ( 'ls' )
.arg ( '-o' )
.saída ( )
.esperar ( 'Falha ao executar o comando' ) ;
se output.status.success ( ) {
deixar stdout = String::from_utf8_lossy ( & output.stdout ) ;
println ! ( 'Saída do comando: \n {}' , stdout ) ;
} outro {
deixar stderr = String::from_utf8_lossy ( & output.stderr ) ;
eprintln ! ( 'Falha no comando: \n {}' , stderr ) ;
saída ( 1 ) ;
}
}
No exemplo dado, começamos importando os módulos necessários. Neste caso, precisamos dos métodos “command” e “exit” do submódulo std::process.
Em seguida, usamos a função Command::new() para executar o comando “ls” e passar os argumentos para o comando.
Se for bem-sucedido, o comando deve retornar a lista de diretórios para o diretório de trabalho atual da seguinte forma:
Conclusão
Exploramos como usar as várias funções e métodos fornecidos pelo módulo std::os e submódulos para executar várias operações em sistemas Linux e semelhantes ao Unix. Lembre-se de que o módulo std::os é um módulo extenso que contém uma coleção mais ampla de recursos do que os demonstrados neste tutorial.