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

117

Sono abituato ad avere il monitoraggio del sistema nel pannello Gnome in alto: CPU, Temperatura, Net, Fan-Speed. (vedi screenshot qui 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 è:

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

    
posta tobi 10.03.2011 - 07:38
fonte

10 risposte

56

Esattamente come il vecchio indicatore di gnome: link

Nota dal link: Una volta installato, lancia System Load Indicator da Dash. A differenza delle vecchie applet di gnome, ecco come aggiungere questi indicatori al pannello.

    
risposta data zarej 04.05.2011 - 00:02
fonte
44

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 delle applicazioni. Sfortunatamente non tutti sono disponibili per Natty, ma almeno ho un monitor di carico del sistema molto semplice (indicatore-sysmonitor) e un indicatore meteorologico (indicatore-meteo) funzionante.

Faiclicsulpulsanteperinstallare:

  • Quali indicatori di applicazione sono disponibili?
risposta data Leo 18.04.2011 - 10:35
fonte
20

Ecco un monitor di sistema rapido e sporco che ho hackerato insieme a python:

Utilizza"Indicatore Monitor di sistema" ( qui ) per chiamare lo script che ho scritto. Per usarlo:

  1. installa indicator-sysmonitor . Per farlo, esegui il seguente comando:

    sudo apt-add-repository ppa:alexeftimie/ppa && sudo apt-get update && sudo apt-get install indicator-sysmonitor
    
  2. copia lo script di seguito in un file chiamato sysmonitor

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

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

  5. scegli"usa questo comando" e dagli il percorso al 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 linee

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à di 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)
    
risposta data krumpelstiltskin 28.04.2011 - 02:30
fonte
13

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

link qui. Una volta installato lo troverai in Applicazioni & gt; Accessori & gt; Indicatore del monitor Sysyem e apparirà come in Unity;

    
risposta data scouser73 15.04.2011 - 22:50
fonte
5

La mia opinione sul problema: link

Screenshot:

    
risposta data nortalf 20.05.2011 - 16:26
fonte
4

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

    
risposta data Christoph 16.04.2011 - 21:41
fonte
4

È possibile installare una porta dell'indicatore del monitor del sistema gnome da: link

    
risposta data Bart Vermeulen 09.05.2011 - 22:00
fonte
3

Non è nel pannello superiore, ma puoi usare Conky .

Non uso Conky, ma ci sono alcuni temi sottili là fuori e penso che puoi farcela sempre in primo piano. (Anche se non so quale parte dello schermo sarebbe buona da coprire ...)

    
risposta data idbrii 05.04.2011 - 20:51
fonte
2

Penso che per ora sarà la cosa più vicina. monitor Cpu

    
risposta data DexterP17 10.03.2011 - 16:59
fonte
-1

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

Si trova negli archivi standard di Ubuntu, quindi basta installarlo su Software Center.

Vedi il confronto in questo screenshot.

Come puoi vedere, ksysguard è molto meglio.

    
risposta data conualfy 24.02.2013 - 08:13
fonte

Leggi altre domande sui tag