Título alternativo: How to get CPU usage per core with python
Teste de indexação do google ;)

Mais um post para a série “Parseando o /proc” [1]. Dessa vez sem motivo explícito, apenas diversão!

Ambientes de testes:

  • Ubunto c/ 1 núcleo e Python 2.6
  • Ubunto c/ 2 núcleos e Python 2.6
  • CentOS c/ 4 núcleos e Python 2.4.
  • Comparei os resultados através do htop e obtive uma proximidade alta nos valores, as diferenças se dão provavelmente pelo momento e duração da medição!

    Quem puder testar em ambientes com mais núcleos ou uso intensivo da CPU e comparar com as ferramentas do sistema por favor me de um feedback

    E quem rir da qualidade do meu inglês nos comentários eu vou banir o ip! :)

    ?View Code PYTHON
    #!/usr/bin/env python
    import time
    import os
     
    # [ reference ]
    # Detect number of cpus
    # http://www.boduch.ca/2009/06/python-cpus.html
    # Get cpu usage (But this example is not working 100%)
    # http://ubuntuforums.org/showpost.php?p=853257&postcount=4
     
    INTERVAL = 2
     
    class CPUUsage:
        def __init__(self):
            self.cores = self.detectCPUs()
     
        def createCoreArray(self):
            cores = []
            for i in range(self.cores):
                cores.append("")
            return cores
     
        def detectCPUs(self):
            if hasattr(os, "sysconf"):
                if os.sysconf_names.has_key("SC_NPROCESSORS_ONLN"):
                    ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
                    if isinstance(ncpus, int) and ncpus > 0:
                        return ncpus
            return 1 # Default
     
        def getTimeList(self):
            core = self.createCoreArray()
     
            statFile = file("/proc/stat", "r")
            if not self.cores == 1:
                statFile.readline()
     
            # this FOR will split lines from proc/stat for every active core
            for cid in range(self.cores):
                # when have just one core, split a different range
                if self.cores == 1:
                    core[cid] = statFile.readline().split(" ")[2:7] # 2:6
                else:
                    core[cid] = statFile.readline().split(" ")[1:6] # 1:5
            statFile.close()
     
            # convert all itens in splited list from STR to INT for every core
            for i in range(len(core[0])):
                for cid in range(self.cores):
                    core[cid][i] = int(core[cid][i])
     
            # return the core list now with INT values inside their cpu values
            # like this: ([core,1,values],[core,2,values],[core,3,values])
            return core
     
        def deltaTime(self,interval):
            coreT1=self.createCoreArray()
            coreT2=self.createCoreArray()
     
            # get core TIME 1 state per core
            coreT1 = self.getTimeList()
            # wait X seconds to get new state core
            time.sleep(interval)
            # get core TIME 2 state per core
            coreT2 = self.getTimeList()
     
            #Get the diference of coreT2.item[i] and coreT1.item[i] for every core
            for i in range(len(coreT1[0])):
                for cid in range(self.cores):
                    coreT2[cid][i] -= coreT1[cid][i]
            return coreT2
     
        def Usage(self):
            core = self.createCoreArray()
            cpuUsage = []
     
            core = self.deltaTime(INTERVAL)
     
            for cid in range(self.cores):
                # sum of user,system and nice usage
                tmp_use = core[cid][0] + core[cid][1]+core[cid][2]
                # 100.00 * usage / sum of usage + idle + waiting
                usage = "%.2f" % ((100.00 * tmp_use) / sum(core[cid]))
                cpuUsage.append(usage)
            return cpuUsage
     
    if __name__ == "__main__":
        # Show usage per core
        #print CPUUsage().Usage()
     
        x = 0
        for item in CPUUsage().Usage():
            x = x + 1
            print "CPU[%s]: %s" % (str(x),str(item))

    RemoveHandler .py

    Precisei disso para impedir a execução dos arquivos .py em uma pasta de um servidor, enquanto eu tentava por chute quase acertei a sintaxe :)

    De qualquer forma, basta colocar no .htaccess e está resolvido.

    E aqui achei várias dicas que podem ser úteis um dia!

    OK, então você usa linux e conhece o ‘top‘, item básico no repertório de qualquer sysadmin, que permite acompanhar algumas informações sobre a carga do sistema e processos. Essa ferramenta antiga e poderosa, é de uma idéia tão simples porem tão prática, que ganhou um termo para designar ferramentas semelhantes, ferramentas “top-like“.

    Para se enquadrar em uma ferramenta top-like o candidato tem que:

  • ser baseado em curses
  • ter atualizações em intervalos pré-definidos
  • ter formato tabulado
  • e opcionalmente permitir interação com os objetos analisados
  • Fiz uma lista com 16 ferramentas top-like disponíveis no Ubuntu 9.04. Enquanto fazia a pesquisa, encontrei pelo menos mais meia dúzia sem pacotes para o ubuntu, e se for considerar as que eu não encontrei esse número deve subir consideravelmente.

    Continue lendo!

    Esse meme está rolando em muitos planetas. Fiquei curioso e resolvi brincar!
    Aí está o resultado.

    Na tarde de sábado eu precisava pegar as portas abertas no servidor, da forma mais Real Time possível.  Primeira idéia? Naturalmente, foi parsear o resultado do netstat e ‘grepar’ o LISTEN ou OUÇA, mas depois imaginei que beber diretamente da fonte pudesse fazer o negócio andar mais rápido. Pesquisa daqui, pesquisa dali, aparentemente o netstat pega suas informações dos arquivos em /proc/net.

    Após umas horinhas consegui o protótipo inicial do código que preciso. Mas durante a caminhada perdi o foco e acabei brincando um pouco mais com o /proc/net/tcp, no fim tinha um netstat simplificado feito em Python.

    Então se alguém algum dia precisar recuperar informações de conexões ao estilo netstat aí está o código:

    ?View Code PYTHON
    #!/usr/bin/python
     
    # Criado por Ricardo Pascal, qualquer dúvida ou
    # contribuição mande para  'pascal.linux' no gmail!
    # Pode usar a vontade só lembre-se de citar a autoria ;)
    # Agradecimento ao pessoal do #python-br na freenode.
    # A galera lá sempre ajuda.
     
    PROC_TCP = "/proc/net/tcp"
    STATE = {
    	    '01':'ESTABLISHED',
    	    '02':'SYN_SENT',
    	    '03':'SYN_RECV',
    	    '04':'FIN_WAIT1',
    	    '05':'FIN_WAIT2',
    	    '06':'TIME_WAIT',
    	    '07':'CLOSE',
    	    '08':'CLOSE_WAIT',
    	    '09':'LAST_ACK',
    	    '0A':'LISTEN',
    	    '0B':'CLOSING'
    	}
     
    tcp_FH = open(PROC_TCP,'r')
    content = tcp_FH.readlines()
    content.pop(0) # remove header
    tcp_FH.close()
     
    def hex2dec(s):
        return int(s,16)
     
    def ip(s):
        return str(hex2dec(s[6:8])) +"."+ str(hex2dec(s[4:6])) +"."+ \
    	    str(hex2dec(s[2:4])) +"."+ str(hex2dec(s[0:2]))
     
    def remove_empty(list):
        return [x for x in list if x !='']
     
    def get_list(c):
        result = []
        result.append(['ID','IP','PORT','rIP','rPORT','STATS'])
        for lines in content:
    	line_array = remove_empty(lines.split(' '))
     
    	line = [line_array[0], line_array[1].split(':'), \
    		line_array[2].split(":"),line_array[3]]
     
    	line = [line[0], ip(line[1][0]), hex2dec(line[1][1]), \
    		ip(line[2][0]), hex2dec(line[2][1]), STATE[(line[3])]]
     
    	result.append(line)
        return result
     
    if __name__ == '__main__':
        for lines in get_list(content):
    	print lines

    PS. Quando eu tiver tempo eu refaço a cama de gato que ta ali na função get_list() e ip().

    Imagino que no final vou acabar usando o Standalone WSGI Server (engine do CherryPy) com a solução apresentada no Static. Mas até lá continuo fazendo meus testes com o CherryPy mesmo.

    É algo que me irrita profundamente, servidores mal aproveitados que por sua vez demandam mais servidores! Alem dos óbvios custos financeiros envolvidos, existe também o fator “Sysadmin puto da cara” e “Sysadmin pagando o pato por falha no desenvolvimento”.

    Essa é a recomendação de leitura da semana:
    Hardware is Expensive, Programmers are Cheap
    Hardware is Expensive, Programmers are Cheap II

    Vale citar que esses textos foram escritos em resposta a esse outro:
    Hardware is Cheap, Programmers are Expensive

    Recebi o convite essa tarde e já estou com o UbuntuOne rodando no meu laptop. O processo de instalação foi extremamente simples, não levou 5 min. No pouco uso que fiz ainda não encontrei nenhum problema, o próximo passo é instalar no dekstop lá onde eu trabalho.

    Até agora só não me agradou o fato de o programa criar a pasta Ubuntu One no meu $HOME. Eu sou meio nervoso em se tratando da organização do meu $HOME, mas acho que posso me acostumar, ou achar onde mudar essa configuração e acrescentar um . (ponto) no início da pasta, afinal o que os olhos não vêem o cérebro não processa =)

    E aqui quem quiser pode ver uma screenshot do UO rodando.

    Função que converte tamanhos de arquivos em um formato legível para humanos. Não lembro onde achei, se alguém souber o link para o site original por favor me avise.
    Update: Enquanto limpava os bookmarks achei o site em que encontrei o código

    ?View Code PYTHON
    #!/usr/bin/python
    import os
    def sizeof_fmt(num):
        for x in ['bytes','KB','MB','GB','TB']:
            if num < 1024.0:
                return "%3.1f%s" % (num, x)
            num /= 1024.0
     
    if __name__ == "__main__":
        lista = os.listdir('.')
        for file in lista:
            print "File: %s Size: %s" % ((file),(sizeof_fmt(os.path.getsize(file))))

    Não sei quando foi, mas aconteceu. Era algo que eu imaginava a algum tempo: um dropbox da vida mantido pela canonical e integrado ao Ubuntu. O projeto em Beta se chama UbuntuOne, e infelizmente depende de um “invitation” para participar ( eu já solicitei o meu ).

    Na versão gratuita são oferecidos 2gb de espaço para o usuário, um ícone na área de notificação permite o acesso as funcionalidades do produto, que no momento são: integração com o Nautilus, capacidade de compartilhar arquivos com outros usuários, sincronização e uma interface Web que permite o acesso aos dados.

    Alem da versão gratuita,existe também a versão paga, que por enquanto tem como único diferencial o espaço, são 10gb por 10 doletas mensais.

    Antes que alguém pergunte, o protocolo em que está sendo desenvolvido o UO é livre e o cliente é open source. Contudo o servidor é da Canonical e não existem planos de disponibilizar o código fonte! Mas nada impede que alguém desenvolva um servidor próprio baseado nas especificações públicas.

    Em um futuro próximo vai ser liberado uma API(fato) em cima do CouchDB(meio-fato) para que desenvolvedores possam projetar suas apps e trabalhar diretamente com o UO. Isso vai servir para facilitar a sincronização de dados dos diversos aplicativos do Ubuntu entre máquinas diferentes.

    Update:
    Leia também: http://tarzxvf.com/ubuntu-one-primeiras-impressoes