¿Qué puede reemplazar la supervisión del sistema en el Panel superior de Gnome en Unity?

116

Estoy acostumbrado a tener la supervisión del sistema en el panel superior de Gnome: CPU, temperatura, red, velocidad del ventilador. (ver la captura de pantalla a continuación)

En Unity, el Panel superior está bloqueado para el nombre de la ventana y el menú global, por lo que no puedo agregar los paneles. Entonces mi pregunta es:

¿Hay alguna forma de reemplazar este tipo de supervisión del sistema (siempre visible, sin ocupar mucho espacio) en Unity?

    
pregunta tobi 10.03.2011 - 07:38

10 respuestas

56

Exactamente como el antiguo indicador de gnome: enlace

Nota del enlace: Una vez instalado, ejecute el Indicador de carga del sistema desde el tablero. A diferencia de los antiguos applets de gnome, esta es la forma de agregar esos indicadores al panel.

    
respondido por el zarej 04.05.2011 - 00:02
44

Encontré la siguiente pregunta y respuesta que resolvió el problema para mí. Contiene una lista de reemplazos para los antiguos applets llamados indicadores de aplicaciones. Desafortunadamente, no todos están disponibles todavía, pero al menos obtuve un monitor de carga del sistema muy básico (indicador-monitor del sistema) y un indicador del tiempo (indicador de clima) funcionando.

Haz clic en el botón para instalar:

respondido por el Leo 18.04.2011 - 10:35
20

Aquí hay un monitor del sistema rápido y sucio que pirateé a partir de python:

Utiliza el "Indicador de Monitor del sistema" ( aquí ) para llamar al script que escribí. Para usarlo:

  1. instalar indicator-sysmonitor . Para hacerlo, ejecute el siguiente comando:

    sudo apt-add-repository ppa:alexeftimie/ppa && sudo apt-get update && sudo apt-get install indicator-sysmonitor
    
  2. copie la secuencia de comandos siguiente en un archivo llamado sysmonitor

  3. hacer el script ejecutable ( chmod +x path-to-file )

  4. haz clic en el indicador y elige "Preferencias".

  5. elige "usar este comando" y dale la ruta al archivo sysmonitor.

aquí está el código:

#!/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

EDITAR: si desea utilizar la memoria (como informe por "parte superior"), agregue las líneas

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

Si tiene la versión 2.0 de psutil, puede obtener el uso de la memoria según lo informado por el Monitor del sistema GNOME con la siguiente línea:

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

Si tiene poco espacio y prefiere tener unidades para la velocidad neta (b, k, M), también puede usar esto

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)
    
respondido por el krumpelstiltskin 28.04.2011 - 02:30
13

Puede descargar e instalar un paquete de software ( .deb ) desde

enlace aquí. Una vez instalado, lo encontrará en Aplicaciones & gt; Accesorios & gt; Indicador de monitor Sysyem y se verá así en Unity;

    
respondido por el scouser73 15.04.2011 - 22:50
5

Mi opinión sobre el problema: enlace

Captura de pantalla:

    
respondido por el nortalf 20.05.2011 - 16:26
4

Hay alguien trabajando en sensores de hardware para el applet del indicador. Consulte ¿Hay algún indicador de sensor de temperatura del hardware?

    
respondido por el Christoph 16.04.2011 - 21:41
4

Puede instalar un puerto del indicador del monitor del sistema gnome desde: enlace

    
respondido por el Bart Vermeulen 09.05.2011 - 22:00
3

No está en el panel superior, pero podría usar Conky .

No uso Conky, pero hay algunos temas delgados por ahí y creo que siempre puedes estar arriba. (Aunque no sé qué parte de la pantalla sería buena para cubrir ...)

    
respondido por el idbrii 05.04.2011 - 20:51
2

Creo que esto será lo más cercano a esto por ahora. Monitor de CPU

    
respondido por el DexterP17 10.03.2011 - 16:59
-1

Probé algunas aplicaciones y encontré que la que está en KDE es para mí la mejor herramienta para monitorear el sistema: ksysguard.

Está en los repositorios estándar de Ubuntu, por lo que solo debe instalarlo en Software Center.

Ver la comparación en esta captura de pantalla.

Como puedes ver, ksysguard es mucho mejor.

    
respondido por el conualfy 24.02.2013 - 08:13

Lea otras preguntas en las etiquetas