linux_stat
1.0.0
Pour lire la version HTML Eyecandy, visitez Linux_Stat.
LinuxStat vous permet de lire l'état d'un système Linux. Il peut vous montrer des statistiques et des usages du processeur, des statistiques et des usages de mémoire, des statistiques et des usages d'échange, l'utilisation de la batterie, les informations du BIOS, les détails du noyau, l'IP local, les détails du système d'exploitation et l'analyse du système d'exploitation +-libération LSB, etc.
Il ne fonctionne que sur Linux, et la détection du système d'exploitation est jusqu'à l'utilisateur de ce joyau.
| Table des matières |
|---|
| Dépendances d'exécution |
| Construire des dépendances |
| Dépendances d'exécution facultative |
| Installation |
| Usage |
| Notes |
| Types de retour |
| Ruby sur les rails |
| Androïde |
| Cloner ce repo |
| Développement |
| Essai |
| Contributif |
| Licence |
| Langues |
# 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
Vous pouvez exécuter Linux_stat sur * AmazonLinux et * CentOS si vous avez Ruby 2.3.0+.
# zypper install gcc ruby ruby-devel make
Vous avez besoin de hwdata pour décoder les fournisseurs et les identifiants de produit si vous utilisez LinuxStat :: USB et / ou LinuxStat :: PCI
Vous pouvez installer Hwdata simplement.
# pacman -S hwids
# apt install hwdata
# emerge --ask sys-apps/hwids
# yum install hwdata
zypper install hwdata
Mais sans Hwdata, il ne montrera pas de telles informations.
Vous pouvez également pointer vers une copie téléchargée du fichier HWDATA (PCI.IDS / USB.IDS).
Suivez la note 7 ci-dessous pour plus d'informations à ce sujet.
Ajoutez cette ligne à Gemfile de votre application:
gem 'linux_stat'Puis exécuter:
$ bundle install
Ou installez-le vous-même comme:
$ gem install linux_stat
Voici les modules LinuxStat et les fonctions du module dans un tableau. Usages.md est généré par la commande linuxstat.rb -md , qui est disponible après l'installation.
Pour plus de facilité d'utilisation, LinuxStat est également affecté à la constante LS. LinuxStat :: USB peut donc être remplacé par LS :: USB par exemple.
| Module LinuxStat | Description |
|---|---|
| LinuxStat :: BIOS | BIOS du système Informaion lié |
| Batterie LinuxStat :: | Les premières informations réalisées par la batterie du système |
| LinuxStat :: CPU | Utilisation du processeur du système et autres informations connexes |
| LinuxStat :: FS | Informations liées au système du système du système. Il est utilisé par le module de système de fichiers. |
| Système de fichiers LinuxStat :: | Utilisation du système de fichiers du système et autres informations connexes |
| LinuxStat :: FTW | File d'arborescence Walk: parcourt un fichier et vous donne des données liées à ses propres fichiers et répertoires sous |
| LinuxStat :: Kernel | Informations liées au noyau du système |
| LinuxStat :: Mémoire | Utilisation de la mémoire du système (RAM) et autres informations connexes |
| LinuxStat :: monte | Informations liées au point de montage du système |
| LinuxStat :: Net | L'utilisation d'Internet du système et d'autres informations |
| LinuxStat :: OS | Informations liées au système d'exploitation du système et fichiers de libération d'analyse du système |
| LinuxStat :: PCI | Informations liées à l'appareil PCI du système (analyse facultative de HWDATA) |
| LinuxStat :: PretifyBytes | Convertir les octets en format lisible par l'homme (kb, kib, etc.) |
| LinuxStat :: Procfs | Lisez le système de fichiers Proc en C pour un accès plus rapide. Accropos utilisé |
| LinuxStat :: Processus | Processus du système et informations connexes |
| LinuxStat :: ProcessInfo | CPU à processus unique du système, usages de mémoire, temps de processeur, etc. Informations |
| LinuxStat :: Swap | Informations liées au swap du système |
| LinuxStat :: Sysconf | Utilisé par d'autres modules LinuxStat, fournit divers détails système comme PageSize, Max Children, Open Files, etc. |
| LinuxStat :: Sysinfo | Utilisé par d'autres modules LinuxStat, un accès plus rapide à des informations telles que Totalram, Freeram, TotalHigh, la moyenne de charge, etc. |
| LinuxStat :: Thermal | Statut thermique du système, informations liées aux ventilateurs, nombre de capteurs, nombre de ventilateurs, etc. |
| LinuxStat :: USB | Informations liées aux périphériques USB du système et autres comptes (analyse facultative de HWDATA) |
| LinuxStat :: Uname | Utilisé par d'autres modules LinuxStat, les informations de l'unité de System dans C, qui est également fournie par la commande uname . |
| LinuxStat :: utilisateur | Les différentes informations liées aux utilisateurs des systèmes, fournit le nom d'utilisateur actuel, le répertoire domestique, etc. |
Pour calculer l'utilisation actuelle, nous devons obtenir deux usages à un intervalle donné et soustraire le 2e du 1er. Par exemple, si le téléchargement actuel ( LinuxStat::Net.total_bytes_received ) est de 1000 octets, et s'il y a 0,1 seconde, il était de 100 octets, cela signifie que 900 octets ont été reçus en 0,1 seconde. Cela signifie que la vitesse actuelle est de 9000 octets / s ou 9 kb / s.
Sans le sondage, il n'est pas vraiment possible de calculer l'utilisation actuelle. Bien que l'utilisation totale puisse être calculée. Un moniteur système fait cela aussi ...
Ainsi, ces méthodes nécessitent un intervalle de sondage:
Ils dorment pendant un intervalle donné puis différencient les données.
Pour plus d'informations, consultez la documentation RI pour les méthodes ci-dessus.
Ces méthodes peuvent ralentir un peu votre application, sauf si vous les implémentez dans un fil.
D'autres méthodes n'ont pas le sommeil mis en œuvre, et ils fonctionnent simplement sous une milliseconde.
Par exemple:
LinuxStat::CPU.stat(0.1)
=> {0=>7.69, 1=>0.0, 2=>0.0, 3=>18.18, 4=>10.0}
Cela dormira pendant 0,1 seconde. Pour être fiable, utilisez un moment comme 0,05 seconde environ.
Si vous souhaitez construire un moniteur système et que vous ne voulez pas attendre, vous devez faire quelque chose comme ceci:
#!/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
Cela n'attendra pas dans chaque boucle pendant 0,5 seconde, mais il ne mettra pas à jour l'utilisation du processeur dans chaque boucle non plus. Donc, ce que vous verrez dans l'utilisation du processeur dans chaque intervalle de 0,5 seconde.
Vous verrez également le comptoir augmente comme un fou. Ce qui signifie qu'il n'est pas attendu 0,5 seconde.
Mais les autres méthodes n'ont pas ce retard, donc dans cet exemple, vous pourrez voir le "téléchargement total" et le "téléchargement total" en temps réel, ainsi que le noyau Linux met à jour les données et Ruby exécute la boucle.
Exécutez simplement la commande LinuxStat.RB pour tester la méthode qui prend le temps mesuré en microsecondes.
Il y a 6 méthodes différentes pour compter le nombre de CPU. Mais ils sont là pour une raison!
Eh bien, cette section démystifie en fait les méthodes.
LinuxStat::CPU.count() : Il obtient le CPU configuré pour le système. Il ne compte pas pour le processeur hotplugged. Si 3 processeurs sur 4 sont hotpluggés, il affichera toujours 4. Il appelle sysconf(_SC_NPROCESSORS_CONF)
LinuxStat::ProcessInfo.nproc(pid = $$) : [Également aliasé à LinuxStat::ProcessInfo.count_cpu() ]
Il renvoie le nombre de processeurs, comme les 3 autres méthodes. Sans aucun argument, c'est comme le fait de courir require 'etc' ; puts Etc.nprocessors
Il y a donc la mise en garde de vérifier ce que le nombre de processeurs est réellement alloué au PID.
Par exemple:
$ 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 avec argument:
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() :Cela renvoie le nombre de processeurs en ligne en tant que tableau. Il n'est pas affecté par les tâches ou quoi que ce soit.
Par exemple:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::CPU.online
=> [0, 1, 3]
En utilisant LinuxStat::CPU.online.count vous que vous comptez le CPU en ligne réel sur votre système.
Tout nombre n de CPU peut être en hotplug dans et hors, et cela le rapportera correctement.
Il obtient simplement les informations de / proc / stat; Mais s'il échoue, il lira / SYS / DÉPICES / SYSTEM / CPU / en ligne et analysera la sortie pour obtenir un tableau.
Le LinuxStat::CPU.count_online Il s'agit d'une méthode plus robuste qui compte le processeur en ligne. Cela ne devrait pas échouer dans la plupart sinon tous les cas! Mais s'il échoue pour des raisons vraiment effrayantes, il reviendra nulle.
LinuxStat::CPU.offline() :
Cela renvoie le nombre de CPU hors ligne en tant que tableau. Il n'est pas affecté par les tâches ou quoi que ce soit.
Par exemple:
irb(main):001:0> require 'linux_stat'
=> true
irb(main):002:0> LinuxStat::CPU.offline
=> [2]
Tout nombre n de CPU peut être en hotplug dans et hors, et cela le rapportera correctement.
Il obtient simplement les informations de / sys / périphériques / système / CPU / hors ligne et analyse la sortie.
LinuxStat::Sysconf.processor_configured() : Cela semble répétitif! En fait, oui, ceci est écrit en C, et il est appelé par LinuxStat::CPU.count .
La différence est que LinuxStat::CPU.count cache la valeur de retour, et cette méthode ne le fait pas.
LinuxStat::Sysconf.processor_online() :Cela peut encore sembler répréhensible à LinuxStat :: CPU.online, mais ce n'est en fait pas!
Si vous utilisez pendant les boucles, il peut ne pas signaler le nombre correct de CPU à chaque fois.
Pire, il peut prendre beaucoup de temps pour mettre à jour le nombre total de CPU.
L'avantage est que c'est assez rapide!
C'est surtout ici juste pour l'exhaustivité à Sysconf.
Le système de fichiers peut prendre des arguments. Par défaut, c'est «/» ou la racine du système ...
Mais par exemple, pour obtenir l'espace disque gratuit de /, vous faites:
$ 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"
Pour voir l'espace libre et total d'un coup de pouce:
$ 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"
Toutes les méthodes LinuxStat :: ProcessInfo peuvent prendre un argument contenant l'ID de processus d'un processus. Par défaut, c'est $$ ou le PID du processus actuel, Ruby, lui-même.
Exemple: dites que vous voulez voir combien CPU Firefox consomme, car vous devez faire ce qui suit (Firefox peut créer beaucoup de processus pour enfants):
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
Pour obtenir l'utilisation de la mémoire de Firefox (par exemple):
$ 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}
Pour obtenir uniquement l'utilisation de la mémoire dans 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"
Le module LinuxStat :: FS vous donne les informations brutes dans le hachage collecté à partir de StatVFS.
Il n'est pas documenté ci-dessus car il n'est pas suggéré d'exécuter cela directement. Mais cela ne devrait causer aucun problème. LinuxStat::Filesystem.stat_raw(fs = '/') le fait automatiquement.
Cela nécessite toujours un argument, et c'est très rapide. Il appelle directement l'API C sans code rubis intermédiaire.
Par exemple, pour obtenir les informations sur «/» 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
Pour en savoir plus à leur sujet, exécutez simplement RI et le nom de la méthode. Pour voir toutes les méthodes disponibles.
La plupart des arguments de LinuxStat :: prennent en charge les arguments.
Par exemple, pour obtenir la maison d'un utilisateur par nom d'utilisateur:
$ 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 pour obtenir la maison de l'utilisateur par 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 pour obtenir l'UID / GID par nom d'utilisateur:
$ 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 pour obtenir l'utilisateur actuel (dans Docker par exemple):
$ 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
=> ""
À droite, le get_login () peut renvoyer une chaîne vide. Mais LinuxStat :: User.get_User également aliasé comme LinuxStat :: User.get_Current_User ne devrait pas renvoyer une chaîne vide dans la plupart des cas.
Les modules PCI et USB reposent en fait sur HWDATA trouvés dans / usr / share / hwdata /. Le ls :: usb.devices_stat et ls :: pci.devices_stat renvoie les informations dans un hachage:
$ 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
Mais si les fichiers ne sont pas disponibles, il ne retournera pas les informations liées à la HWDATA.
Il est donc suggéré d'installer Hwdata. Mais vous pourriez faire face à des problèmes avec Heroku et d'autres PaaS en ligne où vous ne pouvez pas l'installer. La version 1.1.1+ est donc livrée avec une fonction de module appelée hwdata_file = file .
LS::PCI.hwdata_file = File.join(__dir__, 'hwdata', 'pci.ids')
LS::USB.hwdata_file = File.join(__dir__, 'hwdata', 'usb.ids')
En supposant que vous disposez de pci.ids et usb.ids Under ./hwdata Directory.
Sur les rails, vous pouvez mettre ceci (remplacer __dir__ par Rails.root ) dans l'environnement.rb.
Mais notez que le fichier ne peut être défini qu'une seule fois. Il est suggéré de le faire au début de votre application.
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
Il fonctionne sur les modules USB et PCI.
Une fois le fichier défini, appeler LS::PCI.hwdata_file = file est futile.
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
Il reviendra vrai si cela fonctionnait, sinon il reviendra faux. Il est destiné à être fait une fois.
Si vous n'initialisez pas et n'appelez pas les méthodes qui utilisent HWDATA, elles l'appelleront et le premier appel peut prendre 0,1 à 0,2 seconde, les appels consécutifs prendront alors en milliseconde.
Souvent, nous devons travailler avec KB, MB GB, TB ou KIB, MIB, GIB, TIB, etc. et nous avons besoin de travaux pour convertir les octets en unités. Parce que LinuxStat fournit beaucoup de données dans les octets et les kilobytes, il est tout à fait fastidieux de les convertir tout le temps. Pour éviter une telle duplication, il est livré avec un module PrettyBytes.
Par exemple, pour convertir les octets en suffixes décimaux:
$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"
Pour convertir les octets en suffixes binaires:
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"
Pour les convertir en suffixes décimaux métriques courts:
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"
Pour les convertir en suffixes binaires IEC courts:
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"
Il peut soutenir des valeurs jusqu'à des centaines de yottabytes et de yobibytes, ou yb et yib. Vous pouvez également faire des choses comme:
$ 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"
Lisez la documentation RI pour plus d'informations.
En général, si une méthode renvoie un flotteur ou un entier ou une heure, il renverra un flotteur ou un entier ou une heure dans tous les cas. Mais si le statut n'est pas disponible, il renverra nulle.
Si la méthode renvoie un hachage / tableau, il renverra le return hachage / tableau dans tous les cas. Si le statut n'est pas disponible, il renverra un hachage / tableau vide.
Si la méthode renvoie une chaîne, elle renverra la chaîne de retour dans tous les cas. Si le statut n'est pas disponible, il renverra une chaîne congelée vide.
Il n'a pas d'implémentation d'une erreur qui est augmentée lors de l'exécution pour la facilité d'utilisation.
Si vous avez besoin de vérifier une statistique qui renvoie un entier ou un flotteur, et que vous obtenez NIL, vous savez qu'il n'est pas disponible, vous pouvez donc travailler en conséquence. Mais si vous avez besoin de la valeur entière ou flottante dans le format, vous pouvez utiliser la méthode .to_i ou .to_f sur l'objet, NIL sera alors converti en numéro.
Si une erreur est augmentée, elle doit être signalée comme un bogue.
gem linux_stat : $ bundle add linux_stat
Vous pouvez utiliser LinuxStat directement dans les rails.
LinuxStat prend en charge Android OS. Mais il n'est pas rigoureusement testé sur tous les appareils comme les applications Android.
Mais dans Termux, vous pouvez simplement exécuter LinuxStat sans faire face à des problèmes. Notez que le nombre de CPU peut différer en raison de la fonctionnalité de hotplug. Donc, si vous voyez le nombre de processeurs change, il n'y a pas vraiment de rien à faire à ce sujet.
Les problèmes concernant l'exécution de LinuxStat sur Termux sont également les bienvenus.
Les utilisateurs de ce joyau sont invités à suivre l'étape d'installation ci-dessus pour installer ce joyau.
Ce repo est uniquement à des fins de développement. Il a des extensions C qui pourraient faire le pire de votre application stable. Le clonage, la compilation du code à partir de ce dépôt pour une application de production peut être définitif et écraser l'ensemble de l'application directement.
Les gemmes sur Rubygems sont libérées après divers tests.
Donc, installez simplement le gemme, ne clonez pas ce dépôt simplement parce que la version est heurtée ici avec de nouvelles fonctionnalités, et le gemme n'est pas sorti sur Rubygems.org.
Après avoir vérifié le dépôt, compiler et installer ce gemme sur votre machine locale avec bundle exec rake install
Vous pouvez également exécuter bin/console pour une invite interactive qui vous permettra d'expérimenter.
Pour tester tous les modules, exécutez rake install puis exe/linuxstat.rb . Vérifiez également les «tests» ci-dessous.
Comme les autres gemmes, cela n'a pas de test comme RSpec.
Nous suggérons d'utiliser le fichier EXE / LinuxStat.rb sur divers systèmes Linux à tester.
Vous devez d'abord exécuter bundle exec rake install pour compiler et installer ce gemme.
Si vous devez tester un module spécifique, dites le CPU, exécutez-le simplement comme ceci:
$ ruby exe/linuxstat.rb CPU
Ou:
$ ruby exe/linuxstat.rb cpu
Autrement dit, l'argument adopté n'est pas sensible à la cas. Mais si l'argument passé n'est pas disponible et est carrément erroné, il exécutera toutes les méthodes du module. Par exemple, vous ne pouvez pas faire:
$ ruby exe/linuxstat.rb upc
Ce n'est pas un module valide et ne peut pas être exécuté.
Les rapports de bogues et les demandes de traction sont les bienvenus sur GitHub sur https://github.com/souravgoswami/linux_stat.
Le GEM est disponible en open source en vertu des termes de la licence du MIT.
