linux_stat
1.0.0
Para ler a versão Eyecandy HTML, visite Linux_Stat.
O LinuxStat permite ler o status de um sistema Linux. Ele pode mostrar estatísticas e usos da CPU, estatísticas e usos de memória, estatísticas e usos de troca, uso de bateria, informações do bioS, detalhes do kernel, IP local, detalhes do sistema operacional e análise OS + lançamento de LSB, etc.
Ele funciona apenas no Linux e a detecção do sistema operacional é do usuário desta gema.
| Índice |
|---|
| Dependências de tempo de execução |
| Construir dependências |
| Dependências de tempo de execução opcionais |
| Instalação |
| Uso |
| Notas |
| Tipos de retorno |
| Rubi nos trilhos |
| Android |
| Clonando este repo |
| Desenvolvimento |
| Teste |
| Contribuindo |
| Licença |
| Idiomas |
# pacman -S gcc make ruby
# apt install gcc build-essential ruby ruby-dev build-essential
# emerge --ask dev-lang/ruby
# yum install gcc ruby-devel ruby make
Você pode executar Linux_Stat em *AmazonLinux e *Centos se tiver Ruby 2.3.0+.
# zypper install gcc ruby ruby-devel make
Você precisa de hwdata para decodificar o fornecedor e os IDs de produto se você usar LinuxStat :: USB e/ou LinuxStat :: PCI
Você pode instalar o Hwdata simplesmente.
# pacman -S hwids
# apt install hwdata
# emerge --ask sys-apps/hwids
# yum install hwdata
zypper install hwdata
Mas sem hwdata, ele não mostrará essas informações.
Você também pode apontar para uma cópia baixada do arquivo hwdata (pci.ids / usb.ids).
Siga a Nota 7 abaixo para obter mais informações sobre isso.
Adicione esta linha ao GemFile do seu aplicativo:
gem 'linux_stat'E depois execute:
$ bundle install
Ou instale você mesmo como:
$ gem install linux_stat
A seguir, estão os módulos LinuxStat e as funções do módulo em uma tabela. Usages.md é gerado pelo comando linuxstat.rb -md , que está disponível após a instalação.
Para facilitar o uso, o LinuxStat também é atribuído à constante LS. Portanto, o LinuxStat :: USB pode ser substituído por LS :: USB, por exemplo.
| Módulo LinuxStat | Descrição |
|---|---|
| LinuxStat :: BIOS | Informação relacionada ao BIOS do sistema |
| LinuxStat :: Bateria | Primeira informação de bateria do sistema |
| LinuxStat :: CPU | Uso da CPU do sistema e outras informações relacionadas |
| LinuxStat :: fs | Informações relacionadas ao sistema de arquivos do sistema. É usado pelo módulo de sistema de arquivos. |
| LinuxStat :: FileSystem | Uso do sistema de arquivos do sistema e outras informações relacionadas |
| LinuxStat :: ftw | Andar de árvores de arquivo: caminha por um arquivo e fornece dados relacionados aos seus próprios e sub -arquivos e diretórios |
| LinuxStat :: kernel | Informações relacionadas ao kernel do sistema |
| LinuxStat :: Memory | Memória do sistema (RAM) Uso e outras informações relacionadas |
| LinuxStat :: Mounts | Informações relacionadas ao ponto de montagem do sistema |
| LinuxStat :: Net | Uso da Internet do sistema e outras informações |
| LinuxStat :: OS | Informações relacionadas ao sistema operacional do sistema e arquivos de liberação de análise |
| LinuxStat :: PCI | Informações relacionadas ao dispositivo PCI do sistema (análise opcional do HWDATA) |
| LinuxStat :: PrettifyBytes | Converta bytes em formato legível humano (KB, KIB, etc.) |
| LinuxStat :: Procfs | Leia o sistema de arquivos proc em C para acesso mais rápido. Acréscimo usado |
| LinuxStat :: Process | Processos do sistema e informações relacionadas |
| LinuxStat :: ProcessInfo | CPU de processo único do sistema, usos de memória, hora da CPU, etc. Informações |
| LinuxStat :: Swap | Informações relacionadas a troca do sistema |
| LinuxStat :: Sysconf | Usado por outros módulos LinuxStat, fornece vários detalhes do sistema, como PageSize, Children Max, arquivos abertos, etc. |
| LinuxStat :: Sysinfo | Usado por outros módulos LinuxStat, acesso mais rápido a informações como Totalram, Freeram, Totalhigh, Carga média etc. |
| LinuxStat :: Thermal | Status térmico do sistema, informações relacionadas aos fãs, contagem de sensores, contagem de fãs, etc. |
| LinuxStat :: USB | Informações relacionadas ao dispositivo USB do sistema e outras contagens (análise opcional do HWDATA) |
| LinuxStat :: Uname | Usado por outros módulos LinuxStat, as informações não nomeadas do sistema em C, que também são fornecidas pelo comando uname . |
| LinuxStat :: User | Várias informações relacionadas ao usuário da Systems, fornecem nome de usuário atual, diretório doméstico, etc. |
Para calcular o uso atual, precisamos obter dois usos em um determinado intervalo e subtrair o segundo do primeiro. Por exemplo, se o download atual ( LinuxStat::Net.total_bytes_received ) for 1000 bytes e, se 0,1 segundos atrás, foram 100 bytes, isso significa que 900 bytes foram recebidos em 0,1 segundos. Isso significa que a velocidade atual é 9000 bytes/s ou 9 kb/s.
Sem a pesquisa, não é realmente possível calcular o uso atual. Embora o uso total possa ser calculado. Um monitor de sistema faz isso também ...
Assim, esses métodos requerem um intervalo de votação:
Eles dormem por um determinado intervalo e depois diferenciam entre os dados.
Para obter mais informações, observe a documentação do RI para os métodos acima.
Esses métodos podem desacelerar um pouco seu aplicativo, a menos que você os implemente em um thread.
Outros métodos não têm o sono implementado e eles funcionam sob um milissegundo.
Por exemplo:
LinuxStat::CPU.stat(0.1)
=> {0=>7.69, 1=>0.0, 2=>0.0, 3=>18.18, 4=>10.0}
Isso dormirá por 0,1 segundos. Para ser confiável, use um tempo como 0,05 segundos ou mais.
Se você deseja construir um monitor de sistema e não quiser esperar, você precisa fazer algo assim:
#!/usr/bin/ruby
require 'linux_stat'
usages = []
thread = Thread.new { }
counter = 0
while true
thread = Thread.new { usages = LinuxStat::CPU.usages(0.5).values } unless thread.alive?
# clears the screen and prints the info
puts "e[2Je[He[3J"
"#{counter += 1}n"
"e[1;33mTotal CPU Usage:e[0m #{usages[0]}%n"
"#{usages[1..-1].to_a.map.with_index { |x, i| "e[1;33mCore #{i}e[0m => #{x}%n" }.join}"
"Total Download: #{LinuxStat::PrettifyBytes.convert_decimal LinuxStat::Net.total_bytes_received}n"
"Total Upload: #{LinuxStat::PrettifyBytes.convert_decimal LinuxStat::Net.total_bytes_transmitted}"
end
Isso não esperará em todos os loops por 0,5 segundos, mas também não atualizará o uso da CPU em todos os loops. Então, o que você verá no uso da CPU em cada intervalo de 0,5 segundos.
Você também verá o balcão aumenta como um louco. O que significa que não está sendo esperado por 0,5 segundos.
Mas os outros métodos não têm esse atraso; portanto, neste exemplo, você poderá ver o "download total" e o "upload total" em tempo real, assim que o kernel do Linux atualizar os dados e o Ruby executar o loop.
Basta executar o comando linuxstat.rb para testar qual método leva a que tempo medido em microssegundos.
Existem 6 métodos diferentes para contar o número de CPU. Mas eles estão aqui por um motivo!
Bem, esta seção realmente desmistifica os métodos.
LinuxStat::CPU.count() : Ele recebe a CPU configurada para o sistema. Não conta para a CPU quente. Se 3 em cada 4 CPU estiverem quentes, ele ainda será exibido 4. Ele chama sysconf(_SC_NPROCESSORS_CONF)
LinuxStat::ProcessInfo.nproc(pid = $$) : [Também aliases para LinuxStat::ProcessInfo.count_cpu() ]
Ele retorna o número de processadores, como os outros 3 métodos. Sem argumentos, é como a corrida require 'etc' ; puts Etc.nprocessors
Portanto, aí a ressalva de verificar o que o número de processadores é realmente alocado para o PID.
Por exemplo:
$ ruby -r linux_stat -e "puts LS::ProcessInfo.nproc"
4
$ taskset -c 0 ruby -r linux_stat -e "puts LS::ProcessInfo.nproc"
1
$ taskset -c 0-1 ruby -r linux_stat -e "puts LS::ProcessInfo.nproc"
2
$ taskset -c 0-1,3 ruby -r linux_stat -e "puts LS::ProcessInfo.nproc"
3
$ taskset -c 0-1,3 ruby -r linux_stat -e "puts LS::ProcessInfo.nproc "
3
Ou com argumento:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::ProcessInfo.command_name 4775
=> "electron"
irb(main):003:0> LinuxStat::ProcessInfo.nproc 4775
=> 4
LinuxStat::CPU.online() :Isso retorna o número de CPU online como uma matriz. Não é afetado pelo conjunto de tarefas ou qualquer coisa.
Por exemplo:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::CPU.online
=> [0, 1, 3]
Ao usar LinuxStat::CPU.online.count você conta a CPU on -line real em seu sistema.
Qualquer número n de CPU pode ficar quente dentro e fora, e isso relatará isso corretamente.
Apenas recebe as informações de /proc /stat; Mas se falhar, lerá/sys/dispositivos/sistema/cpu/online e analisará a saída para obter uma matriz.
O LinuxStat::CPU.count_online é um método mais robusto que conta a CPU on -line. Não deve falhar na maioria dos casos, se não todos! Mas se falhar por alguns motivos realmente assustadores, retornará nulo.
O LinuxStat::CPU.offline() :
Isso retorna o número de CPU offline como uma matriz. Não é afetado pelo conjunto de tarefas ou qualquer coisa.
Por exemplo:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::CPU.offline
=> [2]
Qualquer número n de CPU pode ficar quente dentro e fora, e isso relatará isso corretamente.
Ele apenas obtém as informações de/sys/dispositivos/sistema/cpu/offline e analisa a saída.
LinuxStat::Sysconf.processor_configured() : Parece repetitivo! Na verdade, sim, isso é escrito em C, e é chamado por LinuxStat::CPU.count .
A diferença é que LinuxStat::CPU.count cache o valor de retorno, e esse método não.
LinuxStat::Sysconf.processor_online() :Isso pode novamente parecer repititivo ao linuxstat :: cpu.online, mas na verdade não é!
Se você estiver usando loops, pode não relatar o número correto de CPU todas as vezes.
Pior, pode levar muito tempo para atualizar o número total de CPU.
O benefício é que é bastante rápido!
É principalmente aqui apenas por uma questão de completude para Sysconf.
O sistema de arquivos pode receber argumentos. Por padrão, é '/' ou a raiz do sistema ...
Mas, por exemplo, para obter o espaço livre em disco de /, você faz:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::Filesystem.free('/').fdiv(1024 ** 3).to_s << " GiB"
=> "35.666873931884766 GiB"
Para ver o espaço livre e total de um thumbdrive:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::Mounts.mount_point('/dev/sdb1')
=> "/run/media/sourav/5c2b7af7-d4c3-4ab4-a035-06d18ffc8e6f"
irb(main):003:0> thumbdrive = _
=> "/run/media/sourav/5c2b7af7-d4c3-4ab4-a035-06d18ffc8e6f"
irb(main):004:0> LinuxStat::Filesystem.free(thumbdrive).fdiv(1024 ** 3).to_s << " GiB"
=> "2.504791259765625 GiB"
irb(main):005:0> LinuxStat::Filesystem.total(thumbdrive).fdiv(1024 ** 3).to_s << " GiB"
=> "29.305004119873047 GiB"
Todos os métodos LinuxStat :: ProcessInfo podem assumir um argumento que contém o ID do processo de um processo. Por padrão, é $$ ou o PID do processo atual, Ruby, por si só.
Exemplo: diga que você quer ver quanto a CPU Firefox está consumindo, pois você precisa fazer o seguinte (o Firefox pode criar muito processo infantil):
LinuxStat::Process.names.find { |x| x[1].include? 'firefox' }[0]
=> 770 # but this differs all the time
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> pid = LinuxStat::Process.names.find { |x| x[1].include? 'firefox' }[0]
=> 770
irb(main):003:0> LinuxStat::ProcessInfo.cpu_usage(pid: pid)
=> 0.0
irb(main):004:0> LinuxStat::ProcessInfo.cpu_usage(pid: pid)
=> 15.0
Para obter o uso da memória do Firefox (por exemplo):
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::ProcessInfo.mem_stat(LinuxStat::Process.names.find { |x| x[1].include? 'firefox'.freeze }[0])
=> {:memory=>468472, :virtual_memory=>4754080, :resident_memory=>814388}
Para obter apenas o uso da memória no MIB:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::ProcessInfo.memory(LinuxStat::Process.names.find { |x| x[1].include? 'firefox'.freeze }[0]).fdiv(1024).round(2).to_s << " MiB"
=> "467.51 MiB"
O módulo LinuxStat :: FS fornece as informações brutas no hash coletadas do StatVFS.
Não está documentado acima, porque não é sugerido executar isso diretamente. Mas isso não deve causar nenhum problema. LinuxStat::Filesystem.stat_raw(fs = '/') isso é automaticamente.
Sempre requer um argumento, e é muito rápido. Ele chama diretamente a API C sem nenhum código de rubi intermediário.
Por exemplo, para obter as informações sobre '/' ou root:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::FS.stat('/')
=> {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>9349843, :block_avail_unpriv=>9349843, :inodes=>58612160, :free_inodes=>56708247, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
irb(main):003:0> t = Time.now ; puts LinuxStat::FS.stat('/') ; Time.now - t
{:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>9349843, :block_avail_unpriv=>9349843, :inodes=>58612160, :free_inodes=>56708247, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
=> 5.0468e-05
Para saber mais sobre eles, basta executar o RI e o nome do método. Para ver todos os métodos disponíveis.
A maioria dos LinuxStat :: User suporta argumentos.
Por exemplo, para obter a casa de um usuário pelo nome de usuário:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::User.home_by_username('root')
=> "/root"
irb(main):003:0> LinuxStat::User.home_by_username('ftp')
=> "/srv/ftp"
irb(main):004:0> LinuxStat::User.home_by_username('mail')
=> "/var/spool/mail"
Ou para levar a casa do usuário pelo GID/UID:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::User.homes_by_uid(1001)
=> ["/home/userx", "/home/userz"]
irb(main):003:0> LinuxStat::User.homes_by_uid(1000)
=> ["/home/sourav"]
irb(main):004:0> LinuxStat::User.home_by_gid(1001)
=> "/home/userx"
irb(main):005:0> LinuxStat::User.home_by_gid(1000)
=> "/home/sourav"
irb(main):006:0> LinuxStat::User.home_by_gid(0)
=> "/root"
Ou para obter o UID/GID pelo nome de usuário:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::User.uid_by_username('root')
=> 0
irb(main):003:0> LinuxStat::User.uid_by_username('ftp')
=> 14
irb(main):004:0> LinuxStat::User.gid_by_username('ftp')
=> 11
irb(main):005:0> LinuxStat::User.gid_by_username('InvalidUser')
=> nil
Ou para obter o usuário atual (no Docker, por exemplo):
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::User.get_current_user
=> "x"
irb(main):003:0> LinuxStat::User.get_user
=> "x"
irb(main):004:0> LinuxStat::User.get_login
=> ""
Certo, o get_login () pode retornar uma string vazia. Mas LinuxStat :: user.get_user também alias como linuxstat :: user.get_current_user não deve retornar uma string vazia na maioria das circunstâncias.
Os módulos PCI e USB realmente dependem do HWData encontrado em/usr/share/hwdata/. O LS :: USB.Devices_Stat e LS :: PCI.Devices_Stat retorna as informações em um hash:
$ ruby -r linux_stat -e "puts LS::USB.devices_stat.to_s[0..200]"
[{:path=>"/sys/bus/usb/devices/1-1.2/", :id=>"04d9:1203", :vendor_id=>"04d9", :product_id=>"1203", :bus_num=>1, :dev_num=>7, :hwdata=>{:vendor=>"Holtek Semiconductor, Inc.", :product=>"Keyboard"}, :aut
Mas se os arquivos não estiverem disponíveis, ele não retornará informações relacionadas ao HWDATA.
Por isso, é sugerido instalar o HWDATA. Mas você pode enfrentar problemas com o Heroku e outros PaaS on -line, onde não pode instalá -lo. Portanto, a versão 1.1.1+ vem com uma função de módulo chamada hwdata_file = file .
LS::PCI.hwdata_file = File.join(__dir__, 'hwdata', 'pci.ids')
LS::USB.hwdata_file = File.join(__dir__, 'hwdata', 'usb.ids')
Supondo que você tenha pci.ids e usb.ids no diretório ./hwdata.
Nos trilhos, você pode colocar isso (substitua __dir__ por Rails.root ) dentro do ambiente.rb.
Mas observe que o arquivo pode ser definido apenas uma vez. É sugerido fazer isso no início do seu aplicativo.
irb(main):001:0' require 'linux_stat'
=> true
irb(main):002:0> LS::USB.hwdata_file_set?
=> false
irb(main):003:0> LS::USB.devices_stat ; ''
=> ""
irb(main):004:0> LS::USB.hwdata_file_set?
=> true
Funciona nos módulos USB e PCI.
Depois que o arquivo é definido, chamando LS::PCI.hwdata_file = file é inútil.
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LS::PCI.initialize_hwdata
=> true
irb(main):003:0> LS::PCI.initialize_hwdata
=> false
Ele retornará verdadeiro se funcionar, caso contrário, retornará falsa. Destina -se a ser feito uma vez.
Se você não inicializar e chamar métodos que utilizam o HWDATA, eles ligarão e a primeira chamada poderá levar de 0,1 a 0,2 segundos, as chamadas consecutivas aceitarão um milissegundo.
Muitas vezes, precisamos trabalhar com KB, MB GB, TB ou KIB, MIB, GIB, TIB, etc. e precisamos de algum trabalho para converter bytes para essas unidades. Como o LinuxStat fornece muitos dados em bytes e kilobytes, é bastante tedioso convertê -los o tempo todo. Para evitar essa duplicação, ele vem com um módulo PrettifyBytes.
Por exemplo, para converter bytes em sufixos decimais:
$irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::PrettifyBytes.convert_decimal(1000)
=> "1.00 kilobyte"
irb(main):003:0> LinuxStat::PrettifyBytes.convert_decimal(10000)
=> "10.00 kilobytes"
irb(main):004:0> LinuxStat::PrettifyBytes.convert_decimal(100000)
=> "100.00 kilobytes"
irb(main):005:0> LinuxStat::PrettifyBytes.convert_decimal(10 ** 13)
=> "10.00 terabytes"
Para converter bytes em sufixos binários:
irb(main):006:0> LinuxStat::PrettifyBytes.convert_binary(1000)
=> "1000.00 bytes"
irb(main):007:0> LinuxStat::PrettifyBytes.convert_binary(10000)
=> "9.77 kibibytes"
irb(main):008:0> LinuxStat::PrettifyBytes.convert_binary(100000)
=> "97.66 kibibytes"
irb(main):009:0> LinuxStat::PrettifyBytes.convert_binary(10 ** 13)
=> "9.09 tebibytes"
Para convertê -los em sufixos decimais curtos métricos:
irb(main):010:0> LinuxStat::PrettifyBytes.convert_short_decimal(1000)
=> "1.00 kB"
irb(main):011:0> LinuxStat::PrettifyBytes.convert_short_decimal(10000)
=> "10.00 kB"
irb(main):012:0> LinuxStat::PrettifyBytes.convert_short_decimal(100000)
=> "100.00 kB"
irb(main):013:0> LinuxStat::PrettifyBytes.convert_short_decimal(10 ** 13)
=> "10.00 TB"
Para convertê -los em sufixos binários curtos da IEC:
irb(main):014:0> LinuxStat::PrettifyBytes.convert_short_binary(1000)
=> "1000 B"
irb(main):015:0> LinuxStat::PrettifyBytes.convert_short_binary(10000)
=> "9.77 KiB"
irb(main):016:0> LinuxStat::PrettifyBytes.convert_short_binary(100000)
=> "97.66 KiB"
irb(main):017:0> LinuxStat::PrettifyBytes.convert_short_binary(10 ** 13)
=> "9.09 TiB"
Ele pode suportar valores até centenas de yottabytes e yobibytes, ou yb e yib. Você também pode fazer coisas como:
$ irb
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::PrettifyBytes.convert_short_decimal(LinuxStat::Mounts.device_stat('/dev/sdb1')[:total])
=> "31.47 GB"
irb(main):003:0> LinuxStat::PrettifyBytes.convert_short_binary(LinuxStat::Mounts.device_stat('/dev/sdb1')[:total])
=> "29.31 GiB"
irb(main):004:0> LinuxStat::PrettifyBytes.convert_short_binary(LinuxStat::Mounts.device_stat('/dev/sdb1')[:used])
=> "26.80 GiB"
irb(main):005:0> LinuxStat::PrettifyBytes.convert_short_binary(LinuxStat::Mounts.device_stat('/dev/sdb1')[:available])
=> "2.51 GiB"
Leia a documentação do RI para obter mais informações.
Em geral, se um método retornar um flutuador ou um número inteiro ou um tempo, ele retornará um flutuador, o número inteiro ou o tempo em todos os casos. Mas se o status não estiver disponível, ele retornará nulo.
Se o método retornar um hash / matriz, ele retornará hash / matriz de retorno em todos os casos. Se o status não estiver disponível, ele retornará um hash / matriz vazio.
Se o método retornar uma string, ele retornará a string de retornar em todos os casos. Se o status não estiver disponível, ele retornará uma corda congelada vazia.
Ele não tem implementação de nenhum erro que seja levantado em tempo de execução para a facilidade de uso.
Se você precisar verificar algumas estatísticas que retornam um número inteiro ou flutuante e você recebe nulo, sabe que não está disponível, para que possa trabalhar de acordo. Mas se você precisar do valor inteiro ou do flutuador em 0 para qualquer formato, poderá usar o método .to_i ou .to_f no objeto, o NIL será convertido em número então.
Se algum erro for aumentado, ele deve ser relatado como um bug.
gem linux_stat : $ bundle add linux_stat
Você pode usar o LinuxStat diretamente em trilhos.
O LinuxStat suporta o sistema operacional Android. Mas não é testado rigorosamente em todos os dispositivos como os aplicativos Android.
Mas no Termux você pode simplesmente executar o LinuxStat sem enfrentar problemas. Observe que a contagem da CPU pode diferir devido ao recurso de hotplugging. Portanto, se você vir a contagem de CPU muda, não há realmente nada a fazer sobre isso.
Problemas relativos a execução do LinuxStat no Termux também são bem -vindos.
Solicita -se que os usuários desta jóia sigam a etapa de instalação acima para instalar esta gema.
Este repositório é apenas para fins de desenvolvimento. Possui extensões C que podem fazer pior no seu aplicativo estável. A clonagem, compilando o código deste repositório para um aplicativo de produção, pode segir falha e travar o aplicativo inteiro diretamente.
Gems em rubygems são liberados após vários testes.
Então, basta instalar a jóia, não clonse este repositório apenas porque a versão é esbarrada aqui com novos recursos, e a gema não está lançada no rubygems.org.
Depois de verificar o repositório, compile e instale esta jóia na sua máquina local com bundle exec rake install
Você também pode executar bin/console para um prompt interativo que permitirá experimentar.
Para testar todos os módulos, execute rake install e, em seguida, exe/linuxstat.rb . Verifique também "teste" abaixo.
Como outras jóias, isso não tem um teste como o RSPEC.
Sugerimos o uso do arquivo exe/linuxstat.rb em vários sistemas Linux para testar.
Primeiro, você precisa executar bundle exec rake install para compilar e instalar esta gema.
Se você precisar testar um módulo específico, digamos a CPU, basta executá -lo assim:
$ ruby exe/linuxstat.rb CPU
Ou:
$ ruby exe/linuxstat.rb cpu
Ou seja, o argumento aprovado não é sensível ao minúsculo. Mas se o argumento aprovado não estiver disponível e totalmente errado, ele executará todos os métodos do módulo. Por exemplo, você não pode fazer:
$ ruby exe/linuxstat.rb upc
Este não é um módulo válido e não pode ser executado.
Relatórios de bug e solicitações de tração são bem -vindos no github em https://github.com/souravgoswami/linux_stat.
A GEM está disponível como código aberto nos termos da licença do MIT.
