Home Page do Portal
Brasil, um país de todos

Changeset 452

Show
Ignorar:
Timestamp:
05/21/08 14:21:43
Autor:
rogeriolino@gmail.com
Mensagem:

Adicionado coleta de particao no modulo computador.

---

Rogério Alencar Lino Filho

Arquivos:

Legenda:

Não modificado
Adicionado
Removido
Modificado
Copiado
Movido
  • cacic/trunk/agente-linux/pycacic/src/coletores/lib/computador.py

    r450 r452  
    4141         
    4242class MotherBoard: 
    43         """Classe MotherBoard, contém informações sobre a Placa Mae""" 
     43        """Classe MotherBoard, contᅢᄅm informaᅢ대ᄉes sobre a Placa Mae""" 
    4444         
    4545        def __init__(self): 
     
    5656 
    5757class CPU: 
    58         """Classe CPU, contém informações sobre a CPU""" 
     58        """Classe CPU, contᅢᄅm informaᅢ대ᄉes sobre a CPU""" 
    5959         
    6060        def __init__(self) : 
     
    115115         
    116116class Video : 
    117         """Classe contendo as informacoes de vídeo""" 
     117        """Classe contendo as informacoes de vᅢᆳdeo""" 
    118118         
    119119        def __init__(self) : 
     
    134134         
    135135        def getResolucao (self) : 
    136                 """ retorna a resolução do video """ 
     136                """ retorna a resoluᅢ댃o do video """ 
    137137                # returns double 
    138138                return self.res 
    139139         
    140140        def setResolucao (self, res) : 
    141                 """ define a resolução do video """ 
     141                """ define a resoluᅢ댃o do video """ 
    142142                # returns  
    143143                self.res = res 
     
    203203 
    204204class Rede: 
    205         """Classe responsável por conter as informações de rede""" 
     205        """Classe responsᅢᄀvel por conter as informaᅢ대ᄉes de rede""" 
    206206         
    207207        def __init__(self): 
     
    321321         
    322322        def __getDNSDomain__(self): 
    323                 """ Pega o domínio """ 
     323                """ Pega o domᅢᆳnio """ 
    324324                dns = commands.getoutput("cat /etc/resolv.conf") 
    325325                pos = dns.find("search ") 
     
    369369         
    370370        def getDHCP(self): 
    371                 """ retorna o endereço IP do servidor DHCP """ 
     371                """ retorna o endereᅢᄃo IP do servidor DHCP """ 
    372372                return self.dhcp 
    373373         
    374374        def getMascara(self): 
    375                 """ retorna a máscara de rede da máquina """ 
     375                """ retorna a mᅢᄀscara de rede da mᅢᄀquina """ 
    376376                # returns string 
    377377                return self.mascara 
     
    383383         
    384384        def getMAC(self): 
    385                 """ retorna o endereco mac da máquina """ 
     385                """ retorna o endereco mac da mᅢᄀquina """ 
    386386                # returns string 
    387387                return self.mac 
     
    398398         
    399399        def getDNSDomain(self): 
    400                 """ retorna o domínio do DNS """ 
     400                """ retorna o domᅢᆳnio do DNS """ 
    401401                #return string 
    402402                return self.dnsdomain 
     
    404404         
    405405class Bios: 
    406         """Classe responsável por conter as informações da Bios""" 
     406        """Classe responsᅢᄀvel por conter as informaᅢ대ᄉes da Bios""" 
    407407         
    408408        def __init__(self) : 
     
    443443 
    444444class HardDisk: 
    445         """Classe responsável por conter as informações sobre o HD""" 
     445        """Classe responsᅢᄀvel por conter as informaᅢ대ᄉes sobre o HD""" 
    446446         
    447447        def __init__(self) : 
     
    484484class PC_XML: 
    485485        """ 
    486                 Classe intermediária responsavel por executar o binario lshw, 
     486                Classe intermediᅢᄀria responsavel por executar o binario lshw, 
    487487                que ira gerar um xml, e entao tratar o xml setando os atributos 
    488488                do Computador atraves do mesmo e por comandos bash. 
     
    496496                        self.placaRede = [] # list 
    497497                        self.hardDisk = [] # list 
     498                        self.partitions = [] # list 
    498499                        self.bios = Bios() # Bios 
    499500                        self.video = [] # list 
     
    626627                if c.getDescricao() != "": 
    627628                        self.cpu.append(c) 
    628                 # Caso exista um novo processador mas a descrição está vazia 
     629                # Caso exista um novo processador mas a descriᅢ댃o estᅢᄀ vazia 
    629630                # assuma que sao mais de um nucleo e replica as informacoes do 
    630631                # ultimo adicionado. Compara tambem com o total de cpu encontrada pelo lshw 
     
    797798                                # convertendo de bytes para megas 
    798799                                hd.setTamanho(int(filho.firstChild.nodeValue) / 1024) 
     800                        elif filho.nodeName == 'node' and filho.attributes['id'].nodeValue[0:6] == 'volume': 
     801                                self.getPartitionInfo(filho) 
    799802                self.hardDisk.append(hd) 
    800      
     803                 
     804        def getPartitionInfo(self, no): 
     805                """Pega as informacoes das particoes atraves do no do XML""" 
     806                p = Particao() 
     807                for filho in no.childNodes: 
     808                        if filho.nodeName == 'description': 
     809                                p.description = filho.firstChild.nodeValue 
     810                        elif filho.nodeName == 'physid': 
     811                                p.physid = int(filho.firstChild.nodeValue) 
     812                        elif filho.nodeName == 'businfo': 
     813                                p.businfo = filho.firstChild.nodeValue 
     814                        elif filho.nodeName == 'logicalname' and p.name == '': 
     815                                p.name = filho.firstChild.nodeValue 
     816                        elif filho.nodeName == 'dev': 
     817                                p.dev = filho.firstChild.nodeValue 
     818                        elif filho.nodeName == 'version': 
     819                                p.version = filho.firstChild.nodeValue 
     820                        elif filho.nodeName == 'serial': 
     821                                p.serial = filho.firstChild.nodeValue 
     822                        elif filho.nodeName == 'capacity': 
     823                                p.size = round(int(filho.firstChild.nodeValue)/1048576) 
     824                                p.__setFreeSize__() 
     825                        elif filho.nodeName == 'configuration': 
     826                                for folha in filho.childNodes: 
     827                                        if folha.nodeName == 'setting' and folha.attributes['id'].nodeValue in ('filesystem', 'mount.fstype'): 
     828                                                p.filesystem = (folha.attributes['value'].nodeValue).upper() 
     829                                                self.partitions.append(p) 
     830                                                return 
     831                        elif filho.nodeName == 'node' and filho.attributes['id'].nodeValue[0:13] == 'logicalvolume': 
     832                                self.getPartitionInfo(filho) 
     833                                return 
     834 
    801835 
    802836class SO_Info: 
     
    9661000                return '' 
    9671001         
    968         def isInstalled(self, pkg_installed, os): 
     1002        def isInstalled(self, os, package): 
    9691003                """ 
    9701004                        Retorna true ou false verificando se o pacote passado por parametro 
     
    9721006                """ 
    9731007                mng = self.__getMng__(os) 
    974                 output = commands.getoutput(self.__getMethod__(os) + pkg_installed) 
    9751008                if mng == 'dpkg': 
    976                         if 'install' in output
     1009                        if not 'deinstall' in package and 'install' in package
    9771010                                return 1 # True 
    9781011                else: 
    9791012                        if output != '': 
    9801013                                return 1 # True 
    981                 return False 
     1014                return 0 
    9821015                         
    9831016        def getAllInstalled(self, os): 
     
    9851018                mng = self.__getMng__(os) 
    9861019                if mng == 'slack': 
    987                         return  commands.getoutput(self.__getMethod__(os)[0:-6]) 
    988                 return commands.getoutput(self.__getMethod__(os)) 
     1020                        ret = commands.getoutput(self.__getMethod__(os)[0:-6]) 
     1021                else: 
     1022                        ret = commands.getoutput(self.__getMethod__(os)) 
     1023                plist = ret.split("\n") 
     1024                packages = [] 
     1025                for package in plist: 
     1026                        if self.isInstalled(os, package): 
     1027                                pos = package.find("\t") 
     1028                                packages.append(package[0:pos]) 
     1029                return packages 
     1030                 
     1031 
     1032class Particao: 
     1033        """ 
     1034                Classe Particoes contem as informacoes da(s)  
     1035                particao(oes) do computador (montagem, tamanho, etc)             
     1036        """ 
     1037         
     1038        def __init__(self): 
     1039                self.size = 0 
     1040                self.freesize = 0 
     1041                self.name = '' 
     1042                self.serial = '' 
     1043                self.description = '' 
     1044                self.filesystem = '' 
     1045                self.physid = 0 
     1046                self.businfo = '' 
     1047                self.dev = '' 
     1048                self.version = '' 
     1049                 
     1050        def getSize(self): 
     1051                """Retorna o tamanho em megas da particao""" 
     1052                return self.size 
     1053         
     1054        def __setFreeSize__(self): 
     1055                desc = commands.getoutput("df -l %s" % self.getName()).split('\n') 
     1056                if len(desc) > 1: 
     1057                        inf = desc[1].split() 
     1058                        if len(inf) > 3: 
     1059                                self.freesize = round(int(inf[3]) / 1024) 
     1060                                return 
     1061                self.freesize = self.size 
     1062         
     1063        def getFreeSize(self): 
     1064                """Retorna o tamanho livre em megas da particao""" 
     1065                return self.freesize 
     1066         
     1067        def getName(self): 
     1068                """Retorna o nome logico da particao, ex.: /dev/hda1""" 
     1069                return self.name 
     1070         
     1071        def getSerial(self): 
     1072                """Retorna uma string contendo o serial da particao""" 
     1073                return self.serial 
     1074         
     1075        def getDescription(self): 
     1076                """Retorna a descricao da particao""" 
     1077                return self.description 
     1078                 
     1079        def getFileSystem(self): 
     1080                """Retorna o tipo do sistema de arquivo da particao, ex.: EXT3, NTFS""" 
     1081                return self.filesystem 
    9891082                 
    9901083 
     
    10031096                self.teclado = devices['teclado'] 
    10041097                self.pacote = Pacotes() 
     1098                self.jreversion = self.__get_jre_version__() 
    10051099                self.ram = '' 
    10061100                self.rom = '' 
     
    10241118                try: 
    10251119                        if not self.isRoot(): 
    1026                                 raise ComputerException('Para executar o programa é necessário estar como super usuário (root).') 
     1120                                raise ComputerException('Para executar o programa ᅢᄅ necessᅢᄀrio estar como super usuᅢᄀrio (root).') 
    10271121                        pc_xml = PC_XML() 
    10281122                        self.ram = pc_xml.ram            
     
    10311125                        self.placaRede = pc_xml.placaRede 
    10321126                        self.hardDisk = pc_xml.hardDisk 
     1127                        self.particoes = pc_xml.partitions 
    10331128                        self.bios = pc_xml.bios 
    10341129                        self.video = pc_xml.video 
     
    10391134                        raise Exception('%s\n\nO programa foi abortado de forma prematura.\n' % e.message) 
    10401135                        sys.exit() 
     1136                         
     1137        def __get_jre_version__(self): 
     1138                """Retorna o hostname da maquina atraves de socket""" 
     1139                java = commands.getoutput('java -version') 
     1140                pos = java.find("java version ") 
     1141                if pos == 0: 
     1142                        pos2 = java.find('"', pos+14) 
     1143                        java = java[pos+14:pos2] 
     1144                return java 
    10411145         
    10421146        def __get_host_name__(self): 
     
    10691173         
    10701174        def getSO (self) : 
    1071                 """ retorna string contendo sistema operacional """ 
     1175                """Retorna string contendo sistema operacional """ 
    10721176                # returns string 
    10731177                return self.so   
     1178         
     1179        def getJREVersion(self): 
     1180                """Retorna a versao do Java Runtime Environment """ 
     1181                return self.jreversion 
    10741182         
    10751183        def getPacotes(self): 
     
    10821190         
    10831191        def getHostName(self) : 
    1084                 """ retorna host name """ 
     1192                """Retorna host name """ 
    10851193                # returns string 
    10861194                return self.hostName     
    10871195                 
    10881196        def getPlacaMae(self) : 
    1089                 """ retorna objeto MotherBoard com as informacoes da placa mae """ 
     1197                """Retorna objeto MotherBoard com as informacoes da placa mae """ 
    10901198                # returns string  
    10911199                return self.placaMae 
    10921200         
    10931201        def getCPU(self) : 
    1094                 """ retorna lista de cpus do micro """ 
     1202                """Retorna lista de cpus do micro """ 
    10951203                # returns list 
    10961204                return self.cpu  
    10971205         
    10981206        def getRam(self) : 
    1099                 """ retorna objeto RAM com descricao das memorias ram do micro """ 
     1207                """Retorna objeto RAM com descricao das memorias ram do micro """ 
    11001208                # returns RAM 
    11011209                return self.ram  
    11021210         
    11031211        def getHardDisk(self) : 
    1104                 """ retorna lista de objetos HD """ 
     1212                """Retorna lista de objetos HD """ 
    11051213                # returns list 
    1106                 return self.hardDisk     
     1214                return self.hardDisk 
     1215         
     1216        def getPartitions(self): 
     1217                """Retorna lista de objetos Particao """ 
     1218                # returns list 
     1219                return self.particoes 
    11071220         
    11081221        def getAudio(self) : 
     
    11121225         
    11131226        def getVideo(self) : 
    1114                 """ retorna lista de placa de video """ 
     1227                """Retorna lista de placa de video """ 
    11151228                # returns list 
    11161229                return self.video 
    11171230         
    11181231        def getRom(self) : 
    1119                 """ retorna lista de midias ROM """ 
     1232                """Retorna lista de midias ROM """ 
    11201233                # returns list 
    11211234                return self.rom 
    11221235         
    11231236        def getPlacaRede(self) : 
    1124                 """ retorna lista de placas de redes """ 
     1237                """Retorna lista de placas de redes """ 
    11251238                # returns list 
    11261239                return self.placaRede 
    11271240         
    11281241        def getIPAtivo(self, server): 
    1129                 """ retorna o endereco de IP que conecta no server especificado """ 
     1242                """Retorna o endereco de IP que conecta no server especificado""" 
    11301243                ips = urlparse(server)[1] 
    11311244                if ips == "": 
    1132                         raise ComputerException("Endereço do Servidor inválido. Não foi possível detectar o ip ativo.") 
     1245                        raise ComputerException("Endereᅢᄃo do Servidor invᅢᄀlido. Nᅢᆪo foi possᅢᆳvel detectar o ip ativo.") 
    11331246                ips = socket.gethostbyname(ips)          
    11341247                return Rede().getIPAtivo(ips) 
    11351248         
    11361249        def getMACAtivo(self, ip): 
    1137                 """ retorna o endereco de IP que conecta no server especificado """                    
     1250                """Retorna o endereco de IP que conecta no server especificado"""                      
    11381251                return Rede().__getMac__(ip).replace(':','-') 
    11391252         
    11401253        def getModem(self) : 
    1141                 """ retorna lista de modens """ 
     1254                """Retorna lista de modens""" 
    11421255                # returns list 
    11431256                return self.modem 
    11441257         
    11451258        def getBios(self) : 
    1146                 """ retorna um objeto do tipo Bios """ 
     1259                """Rtorna um objeto do tipo Bios""" 
    11471260                # returns Bios 
    11481261                return self.bios