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

117

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)

captura de pantalla del panel Gnome 2 que muestra los applets del monitor del sistema

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?

tobi
fuente

Respuestas:

44

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.

ingrese la descripción de la imagen aquí

Haga clic en el botón para instalar:

Instalar a través del centro de software

León
fuente
20

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

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". Ejemplo que muestra que

  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)
krumpelstiltskin
fuente
gracias James por el formato y el paso que falta (apt-add-repository).
krumpelstiltskin
¿Podría decirme cómo podría obtener el% de RAM en lugar del uso del disco?
Vijay
2
@neo: crea una función que analice "/ proc / meminfo" como la llamada "getInOut ()" (los campos en meminfo se explican por sí mismos). Luego llame a su nueva función con makeSample (). Si hay demanda para esto, escribiré y publicaré el código.
krumpelstiltskin
1
@neo: agregué las líneas para el uso de memoria a la publicación. Si el uso de mem es todo lo que desea, le sugiero que elimine todas las demás líneas del script para que Python no tenga que analizarlas.
krumpelstiltskin
1
Descubrí lo mismo y escribí un breve script de Perl que monitorea la utilización de la red.
Nathan Osman
3

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

idbrii
fuente
+1 He estado usando Conky para esto exactamente (como reemplazo del applet del monitor del sistema). Es extremadamente configurable y es probable que tome un poco de trabajo obtener el resultado deseado. Para algunas configuraciones atractivas e interesantes, he estado usando una sugerida en webupd8.org
belacqua
-1

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. Cuánto procesador utiliza Gnome System Monitor frente a KDE System Monitor (ksysguard)

Como puede ver, ksysguard es mucho mejor.

conualfy
fuente
¿Encaja eso en el panel?
Robert Siemer