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

Estoy acostumbrado a tener monitoreo del sistema en el panel superior de Gnome: CPU, temperatura, red, velocidad del ventilador. (ver 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 applets del panel. Entonces mi pregunta es:

¿Hay alguna manera de reemplazar este tipo de monitoreo del sistema (siempre visible, sin ocupar mucho espacio) en Unity?

Exactamente como el viejo indicador de gnomo: http://www.webupd8.org/2011/05/network-memory-and-cpu-usage-indicator.html#more

Nota del enlace: Una vez instalado, inicie 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.

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

Haga clic en el botón para instalar:

• ¿Qué indicadores de aplicación están disponibles?

Aquí hay un monitor de sistema rápido y sucio que pirateé juntos desde Python:

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

1. instalar indicator-sysmonitor. Para hacer eso, ejecuta el siguiente comando:

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

2. copie el script a continuación en un archivo llamado sysmonitor

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

4. haga clic en el indicador y elija "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 de "arriba") 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 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), puede usar esto también

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)

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

https://launchpad.net/indicator-sysmonitor/+download aquí. Una vez instalado, lo encontrará en Aplicaciones> Accesorios> Indicador de monitor Sysyem y se verá así en Unity;

Mi opinión sobre el problema: https://gist.github.com/982939

Captura de pantalla:

Hay alguien trabajando en sensores de hardware para el applet indicador. Consulte ¿Hay un indicador de sensor de temperatura de hardware?

Puede instalar un puerto del indicador del monitor del sistema gnome desde: https://launchpad.net/~indicator-multiload/+archive/stable-daily

No está en el panel superior, pero puedes usar Conky .

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

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

Intenté algunas aplicaciones y descubrí que la de KDE es para mí la mejor herramienta de monitoreo del sistema: ksysguard.

Está en los repositorios estándar de Ubuntu, así que simplemente instálelo en el Centro de software.

Vea la comparación en esta captura de pantalla.

Como puede ver, ksysguard es mucho mejor.