Qu'est-ce qui peut remplacer la surveillance du système dans le panneau supérieur de Gnome dans Unity?

117

J'ai l'habitude d'avoir la surveillance du système dans le panneau supérieur de Gnome: CPU, température, réseau, vitesse du ventilateur. (voir capture d'écran ci-dessous)

capture d'écran du panneau Gnome 2 montrant les applets du moniteur système

Dans Unity, le panneau supérieur est verrouillé pour le nom de la fenêtre et le menu global. Par conséquent, je ne peux pas ajouter d'applets de panneau. Donc ma question est:

Existe-t-il un moyen de remplacer ce type de surveillance système (toujours visible, ne prenant pas beaucoup de place) dans Unity?

tobi
la source

Réponses:

44

J'ai trouvé la question suivante et la réponse qui a résolu le problème pour moi. Il contient une liste de remplacements d'anciennes applets appelés indicateurs d'application. Malheureusement, tous ne sont pas encore disponibles pour natty, mais au moins, j’ai un moniteur de base de la charge système (indicateur-sysmonitor) et un indicateur météo (indicateur-météo) en état de marche.

entrez la description de l'image ici

Cliquez sur le bouton pour installer:

Installer via le centre de logiciel

Leo
la source
20

Voici un moniteur système rapide et sale que j'ai piraté en python: barre de menu

Il utilise le "System Monitor Indicator" ( ici ) pour appeler le script que j'ai écrit. Pour l'utiliser:

  1. installer indicator-sysmonitor. Pour ce faire, exécutez la commande suivante:

    sudo apt-add-repository ppa:alexeftimie/ppa && sudo apt-get update && sudo apt-get install indicator-sysmonitor
    
  2. copier le script ci-dessous dans un fichier appelé sysmonitor

  3. rendre le script exécutable ( chmod +x path-to-file)

  4. cliquez sur l'indicateur et choisissez "Préférences". Exemple montrant que

  5. choisissez "utiliser cette commande" et donnez-lui le chemin du fichier sysmonitor.

voici le code:

#!/usr/bin/python

import re
import sys
import time
import psutil





#Functions:_    __    __    __    __    __    __    __    __    __    __    __
#__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \_



#interface |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
net_re = re.compile(r"\s*\S+:\s+(\d+)\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+(\d+)\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+\d+\s+")

def getInOut():
  """
  Get a readout of bytes in and out from /proc/net/dev.
  """

  netfile = "/proc/net/dev"

  try: f = open(netfile)
  except:
    sys.stderr.write("ERROR: can't open "+netfile+".\n")
    sys.exit(2)

  f.readline()    #Burn the top header line.
  f.readline()    #Burn the second header line.

  inb = 0
  outb = 0
  for line in f:
    m = net_re.match(line)
    inb += int(m.group(1))
    outb += int(m.group(2))
  f.close()

  return (inb,outb)



def sampleNet():
  """
  Get a sample of I/O from the network interfaces.
  """
  return makeSample(getInOut)


def makeSample(function):
  inlist = list()
  outlist = list()

  (inbytes, outbytes) = function()
  inlist.append(inbytes)
  outlist.append(outbytes)
  time.sleep(1)

  (inbytes, outbytes) = function()
  inlist.append(inbytes)
  outlist.append(outbytes)

  return (inlist[1] - inlist[0], outlist[1] - outlist[0])



def diskstatWrapper():
  """
  Wrapper for the diskstats_parse function that returns just the in and out.
  """
  ds = diskstats_parse("sda")
  return (ds["sda"]["writes"], ds["sda"]["reads"])



def sampleDisk():
  """
  Get a sample of I/O from the disk.
  """
  return makeSample(diskstatWrapper)





def diskstats_parse(dev=None):
    """
    I found this on stackoverflow.
    (http://stackoverflow.com/questions/3329165/python-library-for-monitoring-proc-diskstats)
    """
    file_path = '/proc/diskstats'
    result = {}

    # ref: http://lxr.osuosl.org/source/Documentation/iostats.txt
    columns_disk = ['m', 'mm', 'dev', 'reads', 'rd_mrg', 'rd_sectors',
                    'ms_reading', 'writes', 'wr_mrg', 'wr_sectors',
                    'ms_writing', 'cur_ios', 'ms_doing_io', 'ms_weighted']

    columns_partition = ['m', 'mm', 'dev', 'reads', 'rd_sectors', 'writes', 'wr_sectors']

    lines = open(file_path, 'r').readlines()
    for line in lines:
        if line == '': continue
        split = line.split()
        if len(split) != len(columns_disk) and len(split) != len(columns_partition):
            # No match
            continue

        data = dict(zip(columns_disk, split))
        if dev != None and dev != data['dev']:
            continue
        for key in data:
            if key != 'dev':
                data[key] = int(data[key])
        result[data['dev']] = data

    return result





#MAIN:    __    __    __    __    __    __    __    __    __    __    __    __
#__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \__/  \_




(indiff, outdiff) = sampleNet()
outstr = ""
outstr += "cpu: "+str(int(psutil.cpu_percent()))+"%\t"
outstr += "net: "+str(indiff/1000)+"|"+str(outdiff/1000)+" K/s\t"

(diskin, diskout) = sampleDisk()
outstr += "disk: "
if(diskin):
  outstr += "+"
else:
  outstr += "o"
outstr += "|"
if(diskout):
  outstr += "+"
else:
  outstr += "o"

print outstr

EDIT: si vous voulez utiliser la mémoire (comme indiqué par "top"), ajoutez les lignes

memperc = int(100*float(psutil.used_phymem())/float(psutil.TOTAL_PHYMEM))
outstr += "mem: "+str(memperc)+"%\t"

Si vous avez la version 2.0 de psutil, vous pouvez obtenir l'utilisation de la mémoire telle que rapportée par le Moniteur système GNOME à l'aide de la ligne suivante:

memperc = int(100*float(psutil.used_phymem()-psutil.cached_phymem())/float(psutil.TOTAL_PHYMEM))

Si vous avez peu d’espace et que vous préférez avoir des unités pour la vitesse nette (b, k, M), vous pouvez aussi l’utiliser

def withUnit(v):
    if v<1024:
      return "%03d" % v+"b";
    if v<1024**2:
      s= ("%f" % (float(v)/1024))[:3];
      if s[-1]=='.':
         s=s[:-1]
      return s +"k";

    return ("%f" % (float(v)/(1024**2)))[:3] +"M";


(indiff, outdiff) = sampleNet()
outstr = ""
outstr += "c"+ "%02d" % int(psutil.cpu_percent())+" "
outstr += "m"+ "%02d" % int((100*float(psutil.used_phymem())/float(psutil.TOTAL_PHYMEM)))+" "

outstr += "d"+withUnit(indiff)+" u"+withUnit(outdiff)
Krumpelstiltskin
la source
merci James pour le formatage et l'étape manquante (apt-add-repository).
Krumpelstiltskin
Pourriez-vous s'il vous plaît me dire comment je pourrais obtenir le% de RAM au lieu de l'utilisation du disque?
Vijay
2
@neo: crée une fonction qui analyse "/ proc / meminfo", un peu comme celle appelée "getInOut ()" (les champs de meminfo sont auto-explicatifs). Appelez ensuite votre nouvelle fonction avec makeSample (). S'il y a une demande pour cela, j'écrirai et posterai le code.
Krumpelstiltskin
1
@neo: j'ai ajouté les lignes d'utilisation de la mémoire à la publication. si vous utilisez tout simplement mem, je vous suggère de supprimer toutes les autres lignes du script afin que python ne soit pas obligé de les analyser.
Krumpelstiltskin
1
J'ai découvert la même chose et écrit un court script Perl qui surveille l'utilisation du réseau.
Nathan Osman le
13

Vous pouvez télécharger et installer un progiciel ( .deb ) à partir de

https://launchpad.net/indicator-sysmonitor/+download ici. Une fois installé, vous le trouverez sous Applications> Accessoires> Indicateur de moniteur Sysyem. Il ressemblera à ceci dans Unity; entrez la description de l'image ici

scouser73
la source
3

Ce n'est pas dans le panneau du haut, mais vous pouvez utiliser Conky .

Je n'utilise pas Conky, mais il existe quelques thèmes minces et je pense que vous pouvez le faire toujours au-dessus. (Bien que je ne sache pas quelle partie de l'écran il serait bon de couvrir ...)

idbrii
la source
+1 J'utilise Conky pour cela exactement (en tant que remplacement d'applet de moniteur système). C'est extrêmement configurable, et il faudra probablement un peu de travail pour obtenir le résultat souhaité. Pour quelques configs attrayantes
belacqua le
-1

J'ai essayé quelques applications et j'ai constaté que celle sur KDE était pour moi le meilleur outil de surveillance du système: ksysguard.

Il se trouve dans les référentiels standard Ubuntu, vous devez donc l'installer dans le Centre logiciel.

Voir la comparaison dans cette capture d'écran. Combien de processeurs Gnome System Monitor utilise-t-il par rapport à KDE System Monitor (ksysguard)?

Comme vous pouvez le constater, ksysguard est bien meilleur.

conualfy
la source
Est-ce que ça tient dans le panneau?
Robert Siemer