O que pode substituir o monitoramento do sistema no painel superior do Gnome no Unity?

Eu costumava ter o monitoramento do sistema no painel principal do Gnome: CPU, temperatura, rede, velocidade do ventilador. (veja a captura de tela abaixo)

No Unity, o painel superior está bloqueado para o nome da janela e o menu global; portanto, não posso adicionar miniaplicativos de painel. Então, minha pergunta é:

Existe uma maneira de substituir esse tipo de monitoramento do sistema (sempre visível, ocupando pouco espaço) no Unity?

Exatamente como o antigo indicador do gnomo: http://www.webupd8.org/2011/05/network-memory-and-cpu-usage-indicator.html#more

Nota do link: Depois de instalado, inicie o System Load Indicator no Dash. Ao contrário dos antigos applets gnome, é assim que se adicionam esses indicadores ao painel.

Encontrei a seguinte pergunta e resposta que resolveu o problema para mim. Ele contém uma lista de substituições para os applets antigos chamados indicadores de aplicativos. Infelizmente, nem todos eles ainda estão disponíveis para o natty, mas pelo menos eu tenho um monitor de carga do sistema muito básico (sysmonitor de indicador) e um indicador do tempo (indicador de tempo) funcionando.

Clique no botão para instalar:

• Quais indicadores de aplicação estão disponíveis?

Aqui está um monitor de sistema rápido e sujo que eu cortei em python:

Ele usa o "System Monitor Indicator" ( aqui ) para chamar o script que eu escrevi. Para usá-lo:

1. instalar indicator-sysmonitor. Para fazer isso, execute o seguinte comando:

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

2. copie o script abaixo em um arquivo chamado sysmonitor

3. torne o script executável ( chmod +x path-to-file)

4. clique no indicador e escolha "Preferências".

5. escolha "use este comando" e forneça o caminho para o arquivo sysmonitor.

aqui está o 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

EDIT: se você quiser o uso da memória (como reportado por "top"), adicione as linhas

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

Se você possui a versão 2.0 do psutil, poderá obter o uso da memória conforme relatado pelo GNOME System Monitor com a seguinte linha:

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

Se você tem pouco espaço e prefere ter unidades para a velocidade líquida (b, k, M), também pode usá-lo

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)

Você pode baixar e instalar um pacote de software ( .deb ) em

https://launchpad.net/indicator-sysmonitor/+download aqui. Uma vez instalado, você o encontrará em Aplicativos> Acessórios> Indicador do Monitor Sysyem e ficará assim no Unity;

Minha opinião sobre o problema: https://gist.github.com/982939

Captura de tela:

Há alguém trabalhando em sensores de hardware para applet de indicador. Consulte Existe um indicador do sensor de temperatura do hardware?

Você pode instalar uma porta do indicador do monitor do sistema gnome em: https://launchpad.net/~indicator-multiload/+archive/stable-daily

Não está no painel superior, mas você pode usar o Conky .

Eu não uso o Conky, mas existem alguns temas finos por aí e acho que você pode fazê-lo sempre no topo. (Embora eu não saiba que parte da tela seria boa para cobrir ...)

Eu acho que isso será a coisa mais próxima disso por enquanto. Monitor da CPU

Tentei algumas aplicações e descobri que a do KDE é para mim a melhor ferramenta de monitoração do sistema: ksysguard.

Ele está nos repositórios padrão do Ubuntu, então você o instala no Software Center.

Veja a comparação nesta captura de tela.

Como você pode ver, o ksysguard é muito melhor.