linux_stat
1.0.0
Para leer la versión HTML EyECandy, visite Linux_stat.
LinuxStat le permite leer el estado de un sistema Linux. Puede mostrarle estadísticas y usos de la CPU, estadísticas y usos de memoria, estadísticas y usos de intercambio, uso de la batería, información de BIOS, detalles del núcleo, IP local, detalles del sistema operativo y liberación del sistema operativo + liberación de LSB, etc.
Solo funciona en Linux, y la detección del sistema operativo es hasta el usuario de esta gema.
| Tabla de contenido |
|---|
| Dependencias de tiempo de ejecución |
| Construir dependencias |
| Dependencias opcionales de tiempo de ejecución |
| Instalación |
| Uso |
| Notas |
| Tipos de devolución |
| Ruby on Rails |
| Androide |
| Clonando este repositorio |
| Desarrollo |
| Pruebas |
| Que contribuye |
| Licencia |
| Lenguas |
# 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
Puede ejecutar Linux_stat en *Amazonlinux y *Centos si tiene Ruby 2.3.0+.
# zypper install gcc ruby ruby-devel make
Necesita hwdata para decodificar el proveedor y las identificaciones de producto si usa LinuxStat :: USB y/o LinuxStat :: PCI
Puede instalar hwdata simplemente.
# pacman -S hwids
# apt install hwdata
# emerge --ask sys-apps/hwids
# yum install hwdata
zypper install hwdata
Pero sin hwdata, no mostrará dicha información.
También puede señalar una copia descargada del archivo hwdata (pci.ids / usb.ids).
Siga la Nota 7 a continuación para obtener más información sobre eso.
Agregue esta línea al archivo gem de su aplicación:
gem 'linux_stat'Y luego ejecutar:
$ bundle install
O instálelo usted mismo como:
$ gem install linux_stat
Los siguientes son los módulos LinuxStat y las funciones del módulo en una tabla. Usages.md se genera mediante el comando linuxstat.rb -md , que está disponible después de la instalación.
Para facilitar el uso, LinuxStat también se asigna a la constante LS. Entonces LinuxStat :: USB se puede reemplazar con LS :: USB, por ejemplo.
| Módulo Linuxstat | Descripción |
|---|---|
| Linuxstat :: BIOS | Información relacionada con el BIOS del sistema |
| LinuxStat :: Batería | Información realizada de la primera batería del sistema |
| Linuxstat :: CPU | Uso de la CPU del sistema y otra información relacionada |
| Linuxstat :: FS | Información relacionada con el sistema del sistema. Se usa por el módulo del sistema de archivos. |
| LinuxStat :: Files System | Uso del sistema de archivos del sistema y otra información relacionada |
| Linuxstat :: ftw | Caminata de árbol de archivos: camina por un archivo y le brinda datos relacionados con sus propios archivos y directorios |
| Linuxstat :: kernel | Información relacionada con el núcleo del sistema |
| LinuxStat :: Memoria | Uso de memoria del sistema (RAM) y otra información relacionada |
| LinuxStat :: Monte | Información relacionada con el punto de montaje del sistema |
| Linuxstat :: net | El uso de Internet del sistema y otra información |
| LinuxStat :: OS | Información relacionada con el sistema operativo del sistema y archivos de lanzamiento de análisis |
| Linuxstat :: PCI | Información relacionada con el dispositivo PCI del sistema (análisis opcional de HWData) |
| Linuxstat :: Prettifybytes | Convierta bytes en formato legible humano (KB, KIB, etc.) |
| LinuxStat :: Procfs | Lea el sistema de archivos PROC en C para un acceso más rápido. Usado |
| LinuxStat :: Process | Procesos del sistema y información relacionada |
| LinuxStat :: ProcessInfo | CPU de proceso único del sistema, usos de memoria, tiempo de CPU, etc. Información |
| Linuxstat :: swap | Información relacionada con el intercambio del sistema |
| Linuxstat :: sysconf | Utilizado por otros módulos de LinuxStat, proporciona varios detalles del sistema como páginas, niños max, archivos abiertos, etc. |
| Linuxstat :: sysinfo | Utilizado por otros módulos de Linuxstat, acceso más rápido a información como TotalRam, Freeram, TotalHigh, promedio de carga, etc. |
| Linuxstat :: térmico | Estado térmico del sistema, información relacionada con el ventilador, recuento de sensores, recuento de ventiladores, etc. |
| Linuxstat :: USB | Información relacionada con el dispositivo USB del sistema y otros recuentos (análisis opcional de HWData) |
| LinuxStat :: Unam | Utilizado por otros módulos de LinuxStat, la información desanimada del sistema en C, que también es proporcionada por el comando uname . |
| Linuxstat :: usuario | La información de los sistemas relacionada con el usuario, proporciona nombre de usuario actual, directorio de inicio, etc. |
Para calcular el uso actual, necesitamos obtener dos usos en un intervalo dado, y reste el segundo del 1er. Por ejemplo, si la descarga actual ( LinuxStat::Net.total_bytes_received ) es de 1000 bytes, y si hace 0.1 segundos, era 100 bytes, eso significa que 900 bytes se recibieron en 0.1 segundos. Eso significa que la velocidad actual es de 9000 bytes/s o 9 kb/s.
Sin las encuestas, no es realmente posible calcular el uso actual. Aunque se puede calcular el uso total. Un monitor del sistema también hace eso ...
Por lo tanto, estos métodos requieren un intervalo de votación:
Duermen durante un intervalo dado y luego diferencian entre los datos.
Para obtener más información, mire la documentación de RI para los métodos anteriores.
Estos métodos pueden ralentizar un poco su aplicación a menos que los implemente en un hilo.
Otros métodos no tienen el sueño implementado, y simplemente trabajan bajo un milisegundo.
Por ejemplo:
LinuxStat::CPU.stat(0.1)
=> {0=>7.69, 1=>0.0, 2=>0.0, 3=>18.18, 4=>10.0}
Esto dormirá durante 0.1 segundos. Para ser confiable, use un tiempo como 0.05 segundos más o menos.
Si desea construir un monitor de sistema y no quiere esperar, debe hacer algo como esto:
#!/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
Esto no esperará en cada bucle durante 0.5 segundos, pero tampoco actualizará el uso de la CPU en cada bucle. Entonces, lo que verá en el uso de la CPU en cada intervalo de 0.5 segundos.
También verá los aumentos de mostrador como Crazy. Lo que significa que no se espera 0.5 segundos.
Pero los otros métodos no tienen este retraso, por lo tanto, en este ejemplo, podrá ver la "descarga total" y la "carga total" en tiempo real, muy pronto como el kernel de Linux actualiza los datos y Ruby ejecuta el bucle.
Simplemente ejecute el comando LinuxStat.RB para probar qué método toma qué tiempo medido en microsegundos.
Hay confusamente 6 métodos diferentes para contar el número de CPU. ¡Pero están aquí por una razón!
Bueno, esta sección en realidad desmitifica los métodos.
LinuxStat::CPU.count() : Obtiene la CPU configurada para el sistema. No cuenta para la CPU de Hotplugged. Si 3 de 4 CPU se calientan, todavía se mostrará 4. Llamará sysconf(_SC_NPROCESSORS_CONF)
LinuxStat::ProcessInfo.nproc(pid = $$) : [También alias a LinuxStat::ProcessInfo.count_cpu() ]
Devuelve el número de procesadores, como los otros 3 métodos. Sin ningún argumento, es como ejecutar require 'etc' ; puts Etc.nprocessors
Entonces, la advertencia de verificar cuál es el número de procesadores que realmente se asignan al PID.
Por ejemplo:
$ 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
O con 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() :Esto devuelve el número de CPU en línea como una matriz. No se ve afectado por el conjunto de tareas ni nada.
Por ejemplo:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::CPU.online
=> [0, 1, 3]
Al usar LinuxStat::CPU.online.count , cuenta la CPU en línea real en su sistema.
Cualquier número N de CPU puede ser calentado dentro y fuera, y esto lo informará correctamente.
Simplemente obtiene la información de /proc /stat; Pero si falla, leerá/sys/dispositivos/sistema/cpu/en línea y analizará la salida para obtener una matriz.
LinuxStat::CPU.count_online Es un método más robusto que cuenta la CPU en línea. ¡No debería fallar en la mayoría de los casos, si no en todos,! Pero si falla por algunas razones realmente espeluznantes, devolverá nulo.
LinuxStat::CPU.offline() :
Esto devuelve el número de CPU fuera de línea como una matriz. No se ve afectado por el conjunto de tareas ni nada.
Por ejemplo:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::CPU.offline
=> [2]
Cualquier número N de CPU puede ser calentado dentro y fuera, y esto lo informará correctamente.
Simplemente obtiene la información de/sys/dispositivos/sistema/CPU/fuera de línea, y analiza la salida.
LinuxStat::Sysconf.processor_configured() :: Suena repetitivo! En realidad, sí, esto está escrito en C, y lo llama LinuxStat::CPU.count .
La diferencia es que LinuxStat::CPU.count almacena el valor de retorno, y este método no.
LinuxStat::Sysconf.processor_online() ::Esto nuevamente puede sonar repititivo a LinuxStat :: CPU.Online, ¡pero en realidad no lo es!
Si está usando bucles mientras no informa el número correcto de CPU cada vez.
Lo peor, puede llevar mucho tiempo actualizar el número total de CPU.
El beneficio es que es bastante rápido!
Es principalmente aquí solo por el bien de la integridad de SYSCONF.
El sistema de archivos puede tomar argumentos. Por defecto, es '/' o la raíz del sistema ...
Pero en aras del ejemplo, para obtener el espacio de disco gratuito de /, usted lo hace:
$ 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 el espacio libre y total de una droga de pulgar:
$ 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 los métodos LinuxStat :: ProcessInfo pueden tomar un argumento que contiene el ID de proceso de un proceso. Por defecto, es $$ o el PID del proceso actual, Ruby, en sí.
Ejemplo: digamos que desea ver cuánto consume Firefox de CPU, para eso debe hacer lo siguiente (Firefox puede crear mucho proceso 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 obtener el uso de memoria de Firefox (por ejemplo):
$ 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 obtener solo el uso de memoria en 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"
El módulo LinuxStat :: FS le brinda la información bruta en el hash recopilada de STATVFS.
No está documentado anteriormente porque no se sugiere ejecutar esto directamente. Pero no debería causar ningún problema. LinuxStat::Filesystem.stat_raw(fs = '/') lo hace automáticamente.
Siempre requiere una discusión, y es muy rápido. Llama directamente a la API C sin ningún código Ruby intermedio.
Por ejemplo, para obtener la información sobre '/' o 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 obtener más información sobre ellos, simplemente ejecute RI y el nombre del método. Para ver todos los métodos disponibles.
La mayoría de los argumentos de LinuxStat :: Admite argumentos.
Por ejemplo, para obtener la casa de un usuario por el nombre de usuario:
$ 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"
O para obtener la casa del usuario por el 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"
O para obtener el UID/GID por nombre de usuario:
$ 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
O para obtener el usuario actual (en Docker por ejemplo):
$ 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
=> ""
Correcto, el get_login () puede devolver una cadena vacía. Pero LinuxStat :: user.get_user también aliased como LinuxStat :: User.get_current_user no debería devolver una cadena vacía en la mayoría de las circunstancias.
Los módulos PCI y USB realmente confían en hwData encontrados en/usr/share/hwdata/. El ls :: usb.devices_stat y ls :: pci.devices_stat Devuelve la información en un 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
Pero si los archivos no están disponibles, no devolverá la información relacionada con HwData.
Por lo tanto, se sugiere instalar hwData. Pero puede enfrentar problemas con Heroku y otros paaños en línea donde no puede instalarlo. Entonces, la versión 1.1.1+ viene con una función de módulo llamada hwdata_file = file .
LS::PCI.hwdata_file = File.join(__dir__, 'hwdata', 'pci.ids')
LS::USB.hwdata_file = File.join(__dir__, 'hwdata', 'usb.ids')
Suponiendo que tiene pci.ids y usb.ids en el directorio ./hwdata.
En los rieles, puede poner esto (reemplazar __dir__ con Rails.root .
Pero tenga en cuenta que el archivo solo se puede configurar una vez. Se sugiere hacer eso al comienzo de su aplicación.
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 en módulos USB y PCI.
Una vez que se establece el archivo, llamar LS::PCI.hwdata_file = file es 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
Devolverá verdadero si funcionó, de lo contrario devolverá falso. Está destinado a hacerse una vez.
Si no inicializa y llama métodos que utilizan hwData, lo llamarán y la primera llamada puede tomar 0.1 a 0.2 segundos, las llamadas consecutivas tomarán menos de un milisegundo.
Muchas veces necesitamos trabajar con KB, MB GB, TB o KIB, MIB, GIB, TIB, etc. y necesitamos algo de trabajo para convertir bytes en esas unidades. Debido a que LinuxStat proporciona muchos datos en bytes y kilobytes, es bastante tedioso convertirlos todo el tiempo. Para evitar tal duplicación, viene con un módulo PrettifyBytes.
Por ejemplo, para convertir bytes en sufijos decimales:
$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 convertir bytes en sufijos binarios:
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 convertirlos en sufijos decimales métricos cortos:
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 convertirlos en sufijos binarios cortos de 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"
Puede admitir valores hasta cientos de Yottabytes y Yobibytes, o YB e Yib. También puedes hacer cosas 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"
Lea la documentación RI para obtener más información.
En general, si un método devuelve un flotador o un entero o una hora, devolverá un flotador o entero o tiempo en todos los casos. Pero si el estado no está disponible, devolverá nulo.
Si el método devuelve un hash / matriz, devolverá el hash / matriz de retorno en todos los casos. Si el estado no está disponible, devolverá un hash / matriz vacío.
Si el método devuelve una cadena, devolverá la cadena de retorno en todos los casos. Si el estado no está disponible, devolverá una cadena congelada vacía.
No tiene implementación de ningún error que se recaude en tiempo de ejecución para la facilidad de uso.
Si necesita verificar algunas estadísticas que devuelvan un entero o flotante, y obtendrá nulo, sabe que no está disponible, por lo que puede trabajar en consecuencia. Pero si necesita el valor entero o flotante en 0 a cualquier formato, puede usar el método .to_i o .to_f en el objeto, nil se convertirá en número.
Si se plantea algún error, debe informarse como un error.
gem linux_stat : $ bundle add linux_stat
Puede usar LinuxStat directamente en Rails.
LinuxStat es compatible con Android OS. Pero no se prueba rigurosamente en todos los dispositivos como aplicaciones de Android.
Pero en Termux puede ejecutar LinuxStat sin enfrentar problemas. Tenga en cuenta que el conteo de CPU puede diferir debido a la función de plugging. Entonces, si ve los cambios en el recuento de CPU, en realidad no hay nada que hacer al respecto.
Los problemas con respecto a la ejecución de LinuxStat en Termux también son bienvenidos.
Se solicita a los usuarios de esta gema que sigan el paso de instalación anterior para instalar esta gema.
Este repositorio es solo para fines de desarrollo. Tiene extensiones C que podrían hacer lo peor a su aplicación estable. La clonación, el código de compilación de este repositorio para una aplicación de producción puede SEG Fault y bloquear toda la aplicación directamente.
Las gemas en Rubygems se liberan después de varias pruebas.
Así que solo instale la gema, no clone este repositorio solo porque la versión se toca aquí con nuevas características, y la gema no está disponible en rubygems.org.
Después de revisar el repositorio, compile e instale esta gema en su máquina local con bundle exec rake install
También puede ejecutar bin/console para un mensaje interactivo que le permitirá experimentar.
Para probar todos los módulos, ejecute rake install y luego exe/linuxstat.rb . También verifique "Pruebas" a continuación.
Al igual que otras gemas, esto no tiene una prueba como RSPEC.
Sugerimos usar el archivo exe/linuxstat.rb en varios sistemas Linux para probar.
Primero debe ejecutar bundle exec rake install para compilar e instalar esta gema.
Si necesita probar un módulo específico, diga la CPU, simplemente ejecutarla así:
$ ruby exe/linuxstat.rb CPU
O:
$ ruby exe/linuxstat.rb cpu
Es decir, el argumento aprobado no es sensible a los casos. Pero si el argumento aprobado no está disponible y es absolutamente incorrecto, ejecutará todos los métodos del módulo. Por ejemplo, no puedes hacer:
$ ruby exe/linuxstat.rb upc
Este no es un módulo válido y no se puede ejecutar.
Los informes de errores y las solicitudes de extracción son bienvenidas en GitHub en https://github.com/souravgoswami/linux_stat.
La gema está disponible como código abierto bajo los términos de la licencia MIT.
