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

Ambientes de testes:

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!

#!/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!

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

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.

Segue a lista:

htop – Sem dúvida a mais famosa das ferramentas top-like, implementa algumas capacidades extras ao top, como cores, capacidade de scroll horizontal e vertical, e uma melhor interação sobre os processos listados.

iotop – Ferramenta que exibe informações de I/O para cada processo. As informações exibidas são: swapin, leitura e escrita em disco e I/O geral com o sistema.

itop – Monitora as interrupções de sistema, basicamente um parser em /proc/interrupts

atop – Monitor para recursos do sistema. Exibe swap, rede, disco, cpu, atividade de processos entre outros. Achei pouco intuitivo.

sntop – “Pinga” uma lista de hosts e indica se estão ativos ou inativos. Deve ser configurado em /etc/sntoprc. Ferramenta bem legal mais meio bugada.

mtop, mytop – Ferramentas que monitoram as querys e o desempenho do banco de dados mysql. Infelizmente o mtop quebrou minha instalação, aparentemente ele tentou instalar a versão 5.0 em cima da versão 5.1 que tenho rodando.

apachetop – Mostra informações sobre o apache, tais como: requisições por segundo, bytes por segundo e as URLs mais populares sendo exibidas. Creio que o pacote esteja com problema no ubuntu 9.04 64 bits, pois gera um um buffer overflow quando tento executa-lo.

ptop – Semelhante ao mtop, mas específico para o postgres.

dnstop – Exibe informações sobre o tráfego de DNS da rede.

virt-top – Exibe informações de sistemas virtualizados: cpu, memoria, uptime. Pode monitorar qualquer sistema de virtualização baseado no libvirt, como o Xen e o KVM.

iptstate – Exibe informações sobre conexões feitas por clientes que passam pelo seu firewall/gateway. É basicamente um netstat que monitora as conexões tratadas pelo iptables. Depende do módulo CONNTRACK.

iftop, pktstat, jnettop – Exibem informações de consumo da rede, cada qual com sua peculiaridade. A imagem mostra o pkstat.

nethogs – Exibe informações de rede, mas ao invés de quebrar o tráfego por protocolo, o nethogs exibe o consumo de banda por processo. Bem interessante.

Por hoje é isso, mas fique ligado! Assim que possível vou escrever um artigo mais aprofundado sobre duas ou três das ferramentas listadas.

Ah, e se você conhece mais ferramentas top-like, sinta-se a vontade para compartilhar nos comentários.

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:

#!/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.

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

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

#!/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))))

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