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

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)

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?

Exactement comme l'ancien indicateur de gnome: http://www.webupd8.org/2011/05/network-memory-and-cpu-usage-indicator.html#more

Note du lien: Une fois installé, lancez System Load Indicator de Dash. Contrairement aux anciennes applets gnome, voici comment ajouter ces indicateurs au panneau.

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.

Cliquez sur le bouton pour installer:

• Quels indicateurs d'application sont disponibles?

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

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".

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)

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;

Mon point de vue sur le problème: https://gist.github.com/982939

Capture d'écran:

Il y a quelqu'un qui travaille sur des capteurs matériels pour indicateur-applet. Voir Existe - t-il un indicateur de capteur de température matériel?

Vous pouvez installer un indicateur de port du système gnome à l’ adresse suivante : https://launchpad.net/~indicator-multiload/+archive/stable-daily

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 ...)

Je pense que ce sera la chose la plus proche pour le moment. Moniteur cpu

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.

Comme vous pouvez le constater, ksysguard est bien meilleur.