Cosa può sostituire il monitoraggio del sistema nel pannello Gnome superiore in Unity?

Sono abituato ad avere il monitoraggio del sistema nel pannello Gnome in alto: CPU, temperatura, rete, velocità della ventola. (vedi screenshot sotto)

In Unity, il pannello superiore è bloccato per il nome della finestra e il menu globale, quindi non posso aggiungere applet del pannello. Quindi la mia domanda è:

Esiste un modo per sostituire questo tipo di monitoraggio del sistema (sempre visibile, occupando poco spazio) in Unity?

Esattamente come il vecchio indicatore gnomo: http://www.webupd8.org/2011/05/network-memory-and-cpu-usage-indicator.html#more

Nota dal collegamento: una volta installato, avviare System Load Indicator da Dash. A differenza delle vecchie applet di gnome, ecco come aggiungere quegli indicatori al pannello.

Ho trovato la seguente domanda e risposta che ha risolto il problema per me. Contiene un elenco di sostituzioni per le vecchie applet chiamate indicatori dell'applicazione. Sfortunatamente non tutti sono ancora disponibili per natty, ma almeno ho avuto un monitor di carico del sistema molto semplice (indicatore-sysmonitor) e un indicatore meteorologico (indicatore-meteo) funzionante.

Fai clic sul pulsante per installare:

• Quali indicatori di applicazione sono disponibili?

Ecco un monitor di sistema veloce e sporco che ho hackerato insieme da Python:

Utilizza "System Monitor Indicator" ( qui ) per chiamare lo script che ho scritto. Per usarlo:

1. installa indicator-sysmonitor. Per fare ciò, eseguire il comando seguente:

   sudo apt-add-repository ppa:alexeftimie/ppa && sudo apt-get update && sudo apt-get install indicator-sysmonitor
   

2. copia lo script seguente in un file chiamato sysmonitor

3. rendere lo script eseguibile ( chmod +x path-to-file)

4. fai clic sull'indicatore e scegli "Preferenze".

5. scegli "usa questo comando" e assegnagli il percorso del file sysmonitor.

ecco il codice:

#!/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: se si desidera l'utilizzo della memoria (come riportato da "top") aggiungere le righe

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

Se hai la versione 2.0 di psutil, puoi ottenere l'utilizzo della memoria come riportato da GNOME System Monitor con la seguente riga:

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

Se hai poco spazio e preferisci avere unità per la velocità della rete (b, k, M) puoi usare anche questo

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)

Puoi scaricare e installare un pacchetto software ( .deb ) da

https://launchpad.net/indicator-sysmonitor/+download qui. Una volta installato, lo troverai in Applicazioni> Accessori> Indicatore monitor Sysyem e apparirà così in Unity;

La mia opinione sul problema: https://gist.github.com/982939

Immagine dello schermo:

C'è qualcuno che lavora su sensori hardware per indicatore-applet. Vedi Esiste un indicatore del sensore di temperatura hardware?

Puoi installare una porta dell'indicatore del monitor di sistema gnome da: https://launchpad.net/~indicator-multiload/+archive/stable-daily

Non si trova nel pannello superiore, ma è possibile utilizzare Conky .

Non uso Conky, ma ci sono alcuni temi sottili là fuori e penso che tu possa farlo sempre al top. (Anche se non so quale parte dello schermo sarebbe utile per coprire ...)

Penso che per ora questa sarà la cosa più vicina ad essa. Monitor cpu

Ho provato alcune applicazioni e ho scoperto che quello su KDE è per me il miglior strumento di monitoraggio del sistema: ksysguard.

È nei repository standard di Ubuntu, quindi è sufficiente installarlo in Software Center.

Vedi il confronto in questo screenshot.

Come puoi vedere, ksysguard è molto meglio.