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

117

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

captura de tela do painel do Gnome 2 mostrando os applets do monitor do sistema

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?

tobi
fonte

Respostas:

44

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.

insira a descrição da imagem aqui

Clique no botão para instalar:

Instale através do centro de software

Leo
fonte
20

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

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". Exemplo mostrando que

  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)
krumpelstiltskin
fonte
agradece a James pela formatação e pela etapa que falta (apt-add-repository).
precisa saber é o seguinte
Poderia me dizer como eu poderia obter a% de RAM em vez do uso do disco?
Vijay
2
@neo: cria uma função que analisa "/ proc / meminfo" como a chamada "getInOut ()" (os campos do meminfo são auto-explicativos). Em seguida, chame sua nova função com makeSample (). Se houver demanda, escreverei e publicarei o código.
Krumpelstiltskin
1
@neo: eu adicionei as linhas para uso de memória no post. se o uso de mem for o que você deseja, sugiro que você remova todas as outras linhas do script para que o python não precise analisá-las.
Krumpelstiltskin #
1
Descobri a mesma coisa e escrevi um pequeno script Perl que monitora a utilização da rede.
Nathan Osman
13

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; insira a descrição da imagem aqui

scouser73
fonte
3

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

idbrii
fonte
+1 Estou usando o Conky exatamente para isso (como uma substituição do miniaplicativo do monitor do sistema). É extremamente configurável e provavelmente levará algum trabalho para obter o resultado desejado. Para algumas configurações de boa aparência e interessantes, eu tenho usado aquele sugerido na webupd8.org
Belacqua
2

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

DexterP17
fonte
-1

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. Quanto processador o Gnome System Monitor usa vs KDE System Monitor (ksysguard)

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

conualfy
fonte
Isso se encaixa no painel?
Robert Siemer