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

Changeset 430

Show
Ignorar:
Timestamp:
05/09/08 13:24:35
Autor:
rogeriolino@gmail.com
Mensagem:

Nova Versao

Arquivos:

Legenda:

Não modificado
Adicionado
Removido
Modificado
Copiado
Movido

  • cacic/trunk/agente-linux/pycacic/src/cacic.py

    r417 r430  
    88from socket import * 
    99from ger_cols import * 
     10from config.io import Writer 
     11from globals import Globals 
    1012 
    1113class Cacic: 
    …… 
    1315    VERSION = '1.0.0' 
    1416     
    15     def __init__(self): 
    16          
    17         sys.path[0] = self.getDir() 
    18          
    19         print "\n\tBem-Vindo ao PyCacic\n" 
    20         try: 
     17    def __init__(self):        
     18        #try:             
     19            if not Globals.INSTALLED: 
     20                self.install() 
     21 
    2122            if not self.isRoot(): 
    2223                raise Exception("Para executar o programa é necessário estar como super usuário (root).") 
     24             
     25            print "\n\tBem-Vindo ao PyCacic\n" 
    2326            # flags do Gerente de Coletas 
    2427            self.gc_stopped = False 
    2528            self.gc_started = False 
    2629            self.gc_ok = False 
    27             self.isforcada = False 
     30            self.isforcada = [] 
    2831            # Gerente de Coletas 
    2932            self.gc = Ger_Cols(self.VERSION) 
    …… 
    5558                # se nao estiver executando e esta habilitado a executar 
    5659                # ou e uma coleta forcada 
    57                 if not self.gc_started and (self.gc_ok or self.isforcada): 
     60                if not self.gc_started and (self.gc_ok or len(self.isforcada) > 0): 
    5861                    # muda estado para nao habilitado 
    5962                    self.gc_ok = False 
    6063                    # inicia coletas 
    61                     self.gc.coleta_forcada = self.isforcada 
    62                     thread.start_new_thread(self.start, ())                     
     64                    self.gc.coletas_forcadas = self.isforcada 
     65                    thread.start_new_thread(self.start, ()) 
    6366                # executa thread para escutar o socket 
    6467                thread.start_new_thread(self.checkSocket, ()) 
    …… 
    6669            # fechando conexao 
    6770            self.udp_sock.close() 
    68         except Exception, e: 
    69             print e  
    70              
    71     def getDir(self): 
    72         av = sys.argv[0] 
    73         if av[0] == "/": 
    74             return os.path.dirname(av) 
    75         else: 
    76             return os.path.dirname(os.getcwd() + "/" + av) 
     71        #except Exception, e: 
     72        #    print e  
    7773     
    7874    def isRoot(self): 
    …… 
    8177            return False 
    8278        return True 
     79     
     80    def install(self): 
     81        """Abre console para configuracao do PyCacic""" 
     82        print "\n\t--- Bem-Vindo a Configuracao do PyCacic ---" 
     83        print "\n\tapos preencher as informacoes abaixo o programa ira iniciar\n" 
     84        addr = raw_input("End. do  Servidor ('ex: http://10.0.0.1'): ") 
     85        user = raw_input("Usuario do Servidor: ") 
     86        pwd = raw_input("Senha: ") 
     87        if raw_input("\n\t*** Os dados estao corretos? [y|n]").lower() != 'y': 
     88            self.install() 
     89        else: 
     90            Writer.setStatus('installed', True) 
     91            if addr[len(addr)-1] == '/': addr = addr[:-1] 
     92            Writer.setServer('address', addr) 
     93            Writer.setServer('username', user) 
     94            Writer.setServer('password', pwd) 
     95        print "\t--- Configuracao concluida com sucesso ---\n\n" 
    8396 
    8497    def start(self): 
    …… 
    8699        try: 
    87100            self.gc_started = True             
    88             if self.isforcada: 
    89                 self.isforcada = False 
    90                 print '*** iniciando coleta forcada ***' 
     101            self.isforcada = [] 
    91102            print(" --- INICIO DAS COLETAS ---") 
    92             print('\tColetas a serem feitas: \n\t%s' % ', '.join(self.gc.coletas)) 
     103            print 'Total Coletas: %s' % len(self.gc.coletores) 
     104            print('\tColetas a serem feitas: \n\t(%s)' % ', '.join(self.gc.coletores.keys())) 
    93105            self.gc.startColeta() 
    94106            self.gc.createDat() 
    …… 
    113125        """Verifica comunicacao com a interface""" 
    114126        data, self.addr = self.udp_sock.recvfrom(self.buf) 
    115         self.isforcada = (data == 'col_hard') 
     127        self.isforcada.append(data) 
    116128        time.sleep(1) 
    117129 
    118130 
    119131if __name__ == '__main__': 
     132    ver =  sys.version_info 
     133    version = int(''.join([ '%s' %sys.version_info[x] for x in range(3)])) 
     134    if version < 240: 
     135        print "ERROR: Python 2.4 or greater required" 
     136        sys.exit(1) 
    120137    Cacic() 
    121      

  • cacic/trunk/agente-linux/pycacic/src/coletores/col_hard.py

    r419 r430  
    1818from time import strftime 
    1919from coletor import * 
    20 from lib.computador import *  
    2120 
    2221class Col_Hard(Coletor): 
    …… 
    2827    def __init__(self, computer): 
    2928        Coletor.__init__(self, computer) 
     29         
     30    def getName(self): 
     31        return "col_hard" 
    3032 
    3133    def start(self): 
    …… 
    5254        # Placas de Video 
    5355        if len(self.computer.getVideo()) > 0: 
    54             cores , desc, vmem = self.computer.getVideo()[0].getCores(), self.computer.getVideo()[0].getDescricao(), self.computer.getVideo()[0].getRam() 
     56            video = self.computer.getVideo()[0] 
     57            cores = video.getCores() 
     58            desc = video.getDescricao() 
     59            vmem = video.getRam() 
     60            resolucao = video.getResolucao() 
    5561        else: 
    56             cores , desc, vmem = '', '', '' 
     62            cores , desc, vmem, resolucao = '', '', '', '' 
    5763        self.addChave('qt_placa_video_cores', cores) 
    5864        self.addChave('te_placa_video_desc', desc) 
     65        self.addChave('te_placa_video_resolucao', resolucao) 
    5966        self.addChave("qt_placa_video_mem", vmem) 
    6067        # Placas de Som 
    …… 
    7784        self.addChave('Inicio', inicio) 
    7885        self.addChave('Fim', strftime("%H:%M:%S")) 
    79          
    80     def getName(self): 
    81         return "col_hard" 
    8286     
    83     def isReady(self): 
    84         return self.getUVCDat(self.OUTPUT_DAT, 'Coleta.Hardware') != self.getChave('UVC') 
    85      
    86     """ 
    87     def dictToPost(self): 
    88         d = {} 
    89         d['te_Tripa_TCPIP']           = self.encripta(self.dicionario['te_Tripa_TCPIP']) 
    90         d['te_Tripa_CPU']             = self.encripta(self.dicionario['te_Tripa_CPU']) 
    91         d['te_Tripa_CDROM']           = self.encripta(self.dicionario['te_Tripa_CDROM']) 
    92         d['te_mem_ram_desc']          = self.encripta(self.dicionario['te_mem_ram_desc']) 
    93         d['qt_mem_ram']               = self.encripta(self.dicionario['qt_mem_ram']) 
    94         d['te_bios_desc']             = self.encripta(self.dicionario['te_bios_desc']) 
    95         d['te_bios_data']             = self.encripta(self.dicionario['te_bios_data']) 
    96         d['te_bios_fabricante']       = self.encripta(self.dicionario['te_bios_fabricante']) 
    97         d['te_placa_mae_fabricante']  = self.encripta(self.dicionario['te_placa_mae_fabricante']) 
    98         d['te_placa_mae_desc']        = self.encripta(self.dicionario['te_placa_mae_desc']) 
    99         d['te_placa_video_desc']      = self.encripta(self.dicionario['te_placa_video_desc']) 
    100         d['qt_placa_video_cores']     = self.encripta(self.dicionario['qt_placa_video_cores']) 
    101         d['qt_placa_video_mem']       = self.encripta(self.dicionario['qt_placa_video_mem']) 
    102         d['te_placa_som_desc']        = self.encripta(self.dicionario['te_placa_som_desc']) 
    103         d['te_teclado_desc']          = self.encripta(self.dicionario['te_teclado_desc']) 
    104         d['te_modem_desc']            = self.encripta(self.dicionario['te_modem_desc']) 
    105         d['te_mouse_desc']            = self.encripta(self.dicionario['te_mouse_desc']) 
    106         return d 
    107     """ 
     87    def isReady(self, dat): 
     88        return self.getUVCDat(dat, 'Coleta.Hardware') != self.getChave('UVC') 
    10889     
    10990    def getFirst(self, list): 

  • cacic/trunk/agente-linux/pycacic/src/coletores/col_network.py

    r424 r430  
     1 
     2import socket 
     3import struct 
     4 
    15from coletor import * 
    26from lib.computador import Rede 
    37from lib.computador import Computador 
    4 import socket 
    5 import struct 
     8from globals import Globals 
    69 
    710class Col_Network(Coletor): 
    …… 
    1215        self.computer = computer 
    1316 
     17    def isReady(self, dat=None): 
     18        # evita coletar network se estiver usando uma XML de outra maquina 
     19        return Globals.PC_XML == "" 
     20 
    1421    def getName(self): 
    1522        return "col_network" 
    …… 
    1926 
    2027    def setDicionario(self): 
    21         """Monta o dicionario"""         
     28        """Monta o dicionario"""       
     29        net = None;   
    2230        for nw in self.computer.getPlacaRede(): 
    23             if nw.getIP() == self.computer.ip_ativo: 
     31            if nw.getIP() == self.computer.ipAtivo: 
    2432                net = nw 
    2533                break 
    2634        self.dicionario.clear() 
    27         self.addChave("te_ip", self.computer.ip_ativo)         
    28         self.addChave('te_dns_primario', net.getDNS()[0]) 
    29         self.addChave('te_dns_secundario', net.getDNS()[1]) 
    30         self.addChave('te_dominio_dns', net.getDNSDomain()) 
    31         self.addChave('te_mascara', net.getMascara()) 
    32         self.addChave('te_nome_host', self.computer.getHostName()) 
    33         self.addChave('te_gateway', net.getGateway()) 
    34         self.addChave("te_serv_dhcp", net.getDHCP()) 
     35        if net != None: 
     36            self.addChave("te_ip", self.computer.ipAtivo)         
     37            self.addChave('te_dns_primario', net.getDNS()[0]) 
     38            self.addChave('te_dns_secundario', net.getDNS()[1]) 
     39            self.addChave('te_dominio_dns', net.getDNSDomain()) 
     40            self.addChave('te_mascara', net.getMascara()) 
     41            self.addChave('te_nome_host', self.computer.getHostName()) 
     42            self.addChave('te_gateway', net.getGateway()) 
     43            self.addChave("te_serv_dhcp", net.getDHCP()) 
    3544     
    36      

  • cacic/trunk/agente-linux/pycacic/src/coletores/coletor.py

    r419 r430  
    1515from lib.arquivo import * 
    1616from lib.ccrypt import * 
     17from lib.computador import Computador 
     18from globals import Globals 
    1719 
    1820class Coletor: 
    …… 
    6365     
    6466     
    65     def isReady(self): 
     67    def isReady(self, dat=None): 
    6668        """ Retorna True se o coletor está pronto/pretende enviar uma coleta, False caso contrário """ 
    6769        return True 

  • cacic/trunk/agente-linux/pycacic/src/coletores/lib/ccrypt.py

    r429 r430  
    3333    AES.key_size = 32 # 32 bytes = 256 bits 
    3434    mode = AES.MODE_CBC 
    35     KEY = 'CacicBrasil' 
     35    KEY = 'CacicES2005' 
    3636    IV = 'abcdefghijklmnop' 
    3737    cipher = AES.new 

  • cacic/trunk/agente-linux/pycacic/src/coletores/lib/ccrypt_lib.py

    r419 r430  
    44""" 
    55import commands, sys 
     6from globals import Globals  
    67 
    78import sys 
    …… 
    1213    # AES.so paths 
    1314    dic = { 
    14            '32'   : '%s/coletores/lib/x32' % sys.path[0], 
    15            '64'   : '%s/coletores/lib/x64' % sys.path[0],  
    16            '32_4' : '%s/coletores/lib/x32/libc4' % sys.path[0], 
     15           '32'   : '%s/coletores/lib/x32' % Globals.PATH, 
     16           '64'   : '%s/coletores/lib/x64' % Globals.PATH,  
     17           '32_4' : '%s/coletores/lib/x32/libc4' % Globals.PATH, 
    1718           } 
    1819    # output uname shell 
    …… 
    2526            TODO: pegar a versao do glib instalada 
    2627        """ 
    27         sys.path.append(dic['32'])         
     28        sys.path.append(dic['32_4'])         
    2829 
    2930else: 

  • cacic/trunk/agente-linux/pycacic/src/coletores/lib/computador.py

    r419 r430  
    2121import socket, fcntl, struct 
    2222from xml.dom import minidom, Node 
     23from globals import Globals 
    2324 
    2425 
    …… 
    115116         
    116117        def __init__(self) : 
     118                self.res = "" 
    117119                self.cores = 0 # int 
    118120                self.ram = 0.0 # double 
    …… 
    128130                # returns  
    129131                self.ram = ram 
     132         
     133        def getResolucao (self) : 
     134                """ retorna a resolução do video """ 
     135                # returns double 
     136                return self.res 
     137         
     138        def setResolucao (self, res) : 
     139                """ define a resolução do video """ 
     140                # returns  
     141                self.res = res 
    130142                 
    131143        def getCores (self) : 
    …… 
    273285                        Gets the Network IP based on this machine IP and the mask. 
    274286                """ 
    275                 longnetmask = struct.unpack('!I', socket.inet_aton(netmask))[0] 
    276                 longip = struct.unpack('!I', socket.inet_aton(ip))[0] 
    277                 longnetwork = longnetmask & longip 
    278                 network = socket.inet_ntoa(struct.pack("!I", longnetwork)) 
    279                 return network 
     287                if netmask != "": 
     288                        longnetmask = struct.unpack('!I', socket.inet_aton(netmask))[0] 
     289                        longip = struct.unpack('!I', socket.inet_aton(ip))[0] 
     290                        longnetwork = longnetmask & longip 
     291                        network = socket.inet_ntoa(struct.pack("!I", longnetwork)) 
     292                        return network 
     293                return "" 
    280294         
    281295        def __getMac__(self, ip): 
    …… 
    291305                ls = commands.getoutput("netstat -rn | grep " + logicalname).split('\n') 
    292306                for l in ls:  
    293                         if self.__getIpList__(l)[0] == '0.0.0.0': 
    294                                 return self.__getIpList__(l)[1] 
     307                        iplist = self.__getIpList__(l) 
     308                        if len(iplist) > 0: 
     309                                if self.__getIpList__(l)[0] == '0.0.0.0': 
     310                                        return self.__getIpList__(l)[1] 
    295311                return '' 
    296312         
    …… 
    493509        def getXML(self): 
    494510                """Executa o binario para gerar arquivo xml com as informacoes do hardware""" 
    495                 lshw = "%s/coletores/lib/lshw" % sys.path[0] 
     511                if Globals.PC_XML != "": 
     512                        f = open(Globals.PC_XML) 
     513                        content = f.read() 
     514                        return content 
     515                 
     516                lshw = "%s/coletores/lib/lshw" % Globals.PATH 
    496517                if os.path.exists(lshw): 
    497518                        # modificando a permissao do arquivo 
    …… 
    519540                        raise ComputerException(e.message) 
    520541                except Exception, e: 
     542                        print e 
     543                        import traceback 
     544                        traceback.print_exc() 
    521545                        raise ComputerException('Erro ao abrir arquivo XML, formato inesperado') 
    522546                 
    …… 
    540564                        if a == 'id' and valor[0:3] == 'pci': 
    541565                            self.getPCIInfo(filho) 
     566                        if a == 'id' and valor == 'display': 
     567                                                self.getVideoInfo(filho) 
    542568                        if a == 'id' and valor == 'bridge': 
    543569                                                self.getRedeInfo(filho) 
    …… 
    550576                if filho.nodeName == 'version': 
    551577                    # expressao regular para pegar data da bios 
    552                     p = re.compile('[0-9][1-9]/[0-9][1-9]/[1-9][0-9][0-9][0-9]') 
     578                    p = re.compile('[0-9]{1,2}/[0-9]{1,2}/[0-9]{1,4}') 
    553579                    self.bios.setData(p.findall(filho.firstChild.nodeValue)[0]) 
    554580                    self.bios.setDescricao(filho.firstChild.nodeValue) 
    …… 
    649675                if filho.nodeName == 'product': 
    650676                    desc2 = filho.firstChild.nodeValue 
    651                 if filho.nodeName == 'width': 
    652                       video.setCores(filho.firstChild.nodeValue) 
     677                #if filho.nodeName == 'width': 
     678                #     video.setCores(filho.firstChild.nodeValue) 
    653679            video.setDescricao(desc1 + ' - ' + desc2) 
    654             video.setRam(self.getVideoSystemInfo())   
     680            self.__getVideoSystemInfo__(video) 
    655681            self.video.append(video)   
    656682                         
    657         def getVideoSystemInfo(self): 
    658             """Pega as informacoes de Video atraves da linhad e comando""" 
     683        def __getVideoSystemInfo__(self, video): 
     684            """Pega as informacoes de Video atraves da linha de comando""" 
    659685            s = commands.getoutput("grep -i video /var/log/Xorg.0.log") 
    660686            s = s.lower() 
    …… 
    664690                fim = (s.find("k",primeiro)) 
    665691                if(primeiro > 0 and fim > 0): 
    666                     return int(s[primeiro:fim])/1024   
    667             return DEFAULT_STRING_VALUE 
     692                    video.setRam(int(s[primeiro:fim])/1024) 
     693            s = commands.getoutput("grep -i *Built-in /var/log/Xorg.0.log") 
     694            pesqBus = s.find("*Built-in mode ") 
     695            if pesqBus > 0: 
     696                primeiro = pesqBus+16 
     697                fim = s.find("\n", primeiro) 
     698                video.setResolucao(s[primeiro:fim]) 
     699            s = commands.getoutput('grep -i "(--) Depth" /var/log/Xorg.0.log') 
     700            pesqBus = s.find("format is ") 
     701            if pesqBus > 0: 
     702                primeiro = pesqBus+10 
     703                fim = s.find(" ", primeiro) 
     704                video.setCores(s[primeiro:fim]) 
    668705   
    669706        def getIDEInfo(self, no): 
    …… 
    954991        def __init__(self): 
    955992                devices = self.__get_input_devices__() 
    956                 self.ip_ativo = '' 
     993                self.ipAtivo = '' 
    957994                self.hostName = self.__get_host_name__() 
     995                self.ultimoLogin = self.__get_last_login__()  
    958996                self.so = SO_Info.getSO() 
    959997                self.mouse = devices['mouse'] 
    …… 
    9781016 
    9791017        def coletar(self): 
    980                 print "COLETAR" 
    9811018                """Inicia a coleta de informacoes do computador""" 
    9821019                try: 
    …… 
    10001037        def __get_host_name__(self): 
    10011038                """Retorna o hostname da maquina atraves de socket""" 
    1002                 return socket.gethostname() 
    1003          
     1039                return socket.gethostname()      
    10041040         
    10051041        def __get_last_login__(self): 

  • cacic/trunk/agente-linux/pycacic/src/coletores/lib/url.py

    r419 r430  
    4545        dados['te_nome_computador'] = defaults['hostname'] 
    4646        dados['padding_key']        = defaults['padding_key'] 
    47         dados['agente']             = defaults['agente_cacic'] 
     47        dados['AgenteLinux']        = defaults['agente_linux'] 
    4848         
    4949        query = urllib.urlencode(dados) 

  • cacic/trunk/agente-linux/pycacic/src/coletores/lib/x32/Crypto/__init__.py

    r419 r430  
    1  

  • cacic/trunk/agente-linux/pycacic/src/config/cacic.conf

    r420 r430  
    22<config> 
    33        <status> 
    4                 <param id="install" value="OK" /> 
    5                 <param id="test" value="NOK" /> 
     4                <param id="installed" value="yes" /> 
     5                <param id="test" value="no" /> 
    66        </status> 
    77        <server id="gerente_web"> 
    …… 
    2222                <coletor id="col_network" page="set_tcp_ip.php" /> 
    2323                <coletor id="col_hard" page="set_hardware.php" /> 
     24                <coletor id="col_soft" page="set_software.php" /> 
     25                <coletor id="col_patr" page="set_patrimonio.php" /> 
    2426        </coletores> 
    2527</config> 

  • cacic/trunk/agente-linux/pycacic/src/config/io.py

    r420 r430  
    1515from xml.dom import minidom, Node 
    1616 
    17  
    1817class IOConfig: 
    1918    """ 
    …… 
    2423        dele.         
    2524    """ 
    26      
     25 
    2726    FILE = '%s/config/cacic.conf' % sys.path[0] 
    2827     
    …… 
    173172        return node.replace(old, ('%s="%s"' % (attrib, value))) 
    174173 
    175     def setServer(address, agent, password): 
    176         """Grava endereco, arquivo e password do Gerente Web no XML""" 
     174    def setServer(node, value): 
     175        """Altera o no especificado das informacoes do servidor""" 
    177176        config = IOConfig.getFile() 
    178177        re_sv = re.compile('<server(?:.|\n)*</server>') 
    179         re_ws = re.compile('<ws.*</ws>') 
    180         re_ad = re.compile('<address.*</address>') 
    181         re_ag = re.compile('<agent.*</agent>') 
    182         re_pw = re.compile('<password.*</password>') 
    183         sv = re_sv.findall(config)[0] 
    184         ws = re_ws.findall(sv)[0] 
    185         ad = re_ad.findall(sv)[0]  
    186         ag = re_ag.findall(sv)[0] 
    187         pw = re_pw.findall(sv)[0]         
     178        re_node = re.compile('<%s.*</%s>' % (node, node)) 
     179        sv = re_sv.findall(config)[0]         
     180        if len(re_node.findall(sv)) == 0: 
     181            return False 
     182        node = re_node.findall(sv)[0]         
    188183        server = sv 
    189         server = server.replace(ws, Writer.setNodeValue(ws, address)) 
    190         server = server.replace(ad, Writer.setNodeValue(ad, address)) 
    191         server = server.replace(ag, Writer.setNodeValue(ag, agent)) 
    192         server = server.replace(pw, Writer.setNodeValue(pw, password)) 
     184        server = server.replace(node, Writer.setNodeValue(node, value)) 
    193185        Writer.saveXML(config.replace(sv, server)) 
    194186         
    …… 
    202194        status = st 
    203195        if (v): 
    204             v = "OK" 
     196            v = "yes" 
    205197        else: 
    206             v = "NOK" 
     198            v = "no" 
    207199        status = status.replace(pr, Writer.setNodeAttrib(pr, "value", v)) 
    208200        Writer.saveXML(config.replace(st, status)) 

  • cacic/trunk/agente-linux/pycacic/src/ger_cols.py

    r417 r430  
    1818from coletores.col_network import * 
    1919from coletores.col_hard import * 
     20from coletores.col_soft import * 
     21from coletores.col_patr import * 
    2022 
    2123from coletores.lib.url import * 
    …… 
    3032 
    3133from config.io import * 
     34 
     35from globals import Globals 
    3236 
    3337 
    …… 
    4448    """ 
    4549     
    46     OUTPUT_DAT = '%s/cacic2.dat' % sys.path[0] 
     50    OUTPUT_DAT = '%s/cacic2.dat' % Globals.PATH 
    4751 
    4852    def __init__(self, version): 
    …… 
    7882        self.update_user = '' 
    7983        self.update_pass = '' 
    80         # coletores 
    81         self.initColetores() 
    8284        # coletas a serem realizadas 
    83         self.coletas = [] 
     85        self.coletores = {} 
    8486        self.coletas_enviar = {} 
    85         self.coleta_forcada = False 
     87        # lista com as coletas forcadas 
     88        self.coletas_forcadas = [] 
     89        # se for True forca todas as coletas 
     90        self.all_forcada = False 
    8691        # Informacoes a serem passadas para o Gerente Web 
    87         self.computador.ip_ativo = self.computador.getIPAtivo(self.cacic_server) 
     92        self.computador.ipAtivo = self.computador.getIPAtivo(self.cacic_server) 
    8893        net = Rede() 
    89         netmask = net.__getMask__(self.computador.ip_ativo) 
    90         iprede = net.__getIPRede__(self.computador.ip_ativo, netmask); 
     94        netmask = net.__getMask__(self.computador.ipAtivo) 
     95        iprede = net.__getIPRede__(self.computador.ipAtivo, netmask); 
    9196        self.defaults = { 
    92             'agente_cacic' : self.coletor.encripta('pycacic'), 
     97            'agente_linux' : self.coletor.encripta('PyCacic'), 
    9398            'user'         : self.coletor.encripta(server['username']), 
    9499            'pwd'          : self.coletor.encripta(server['password']), 
    …… 
    97102            'te_so'        : self.coletor.encripta(self.computador.getSO()), 
    98103            'hostname'     : self.coletor.encripta(self.computador.getHostName()), 
    99             'ip'           : self.coletor.encripta(self.computador.ip_ativo), 
     104            'ip'           : self.coletor.encripta(self.computador.ipAtivo), 
    100105            'id_rede'      : self.coletor.encripta(iprede), 
    101             'mac'          : self.coletor.encripta(self.computador.getMACAtivo(self.computador.ip_ativo)), 
     106            'mac'          : self.coletor.encripta(self.computador.getMACAtivo(self.computador.ipAtivo)), 
    102107            'padding_key'  : self.coletor.getPadding(), 
    103108        }         
    …… 
    105110            'te_versao_cacic'    : version, 
    106111            'te_versao_gercols'  : version, 
    107             'in_chkcacic'        : self.coletor.encripta(Reader.getStatus('install')['value']), 
    108             'in_teste'           : self.coletor.encripta(Reader.getStatus('test')['value']),                 
     112            'in_chkcacic'        : self.coletor.encripta(''), 
     113            'in_teste'           : self.coletor.encripta(''),                 
    109114            'te_workgroup'       : self.coletor.encripta('Desconhecido'), 
    110115            'te_nome_computador' : self.coletor.encripta(self.computador.getHostName()), 
    …… 
    118123        self.separador = '=CacicIsFree=' 
    119124         
    120     def initColetores(self): 
    121         self.coletores = {} 
    122         """ Network """ 
    123         col_network = Col_Network(self.computador) 
    124         self.coletores[col_network.getName()] = col_network 
    125         """ Hardware """ 
    126         col_hard = Col_Hard(self.computador) 
    127         self.coletores[col_hard.getName()] = col_hard 
    128125         
    129126    def start(self): 
    …… 
    169166     
    170167    def addColeta(self, col, valor): 
    171         """Adiciona a coleta na lista, se o seu valor for 'S'""" 
     168        """Adiciona o coletor na lista, se o seu valor for 'S'""" 
    172169        if valor.upper() == 'S': 
    173             self.coletas.append(col) 
     170            self.coletores[col.getName()] = col 
    174171             
    175172    def readXML(self, xml): 
    176173        """ Le o XML gerado pelo servidor WEB """ 
    177174        # returns void 
    178         self.coletas = ['tcp_ip'] 
    179175        self.xml = minidom.parseString(xml) 
    180176        # se nao achar o status==OK, retorna 
    …… 
    182178            raise Exception('Erro ao ler XML do servidor, status não disponível') 
    183179        root = self.xml.getElementsByTagName('CONFIGS')[0] 
     180        # Coletores 
     181        self.coletores.clear() 
     182        self.addColeta(Col_Network(self.computador), 'S') 
    184183        for no in root.childNodes: 
    185184            if no.nodeType == Node.ELEMENT_NODE: 
    …… 
    189188                    # COLETAS 
    190189                    elif no.nodeName == 'cs_coleta_forcada' and self.decode(no.firstChild.nodeValue) == 'OK': 
    191                         self.coleta_forcada = True 
    192                     elif no.nodeName == 'cs_coleta_compart': 
    193                         self.addColeta('col_comp', self.decode(no.firstChild.nodeValue)) 
     190                        self.all_forcada = True 
     191                    elif no.nodeName == 'cs_coleta_compart':                        
     192                        #self.addColeta(None, self.decode(no.firstChild.nodeValue)) 
     193                        pass 
    194194                    elif no.nodeName == 'cs_coleta_hardware': 
    195                         self.addColeta('col_hard', self.decode(no.firstChild.nodeValue)) 
     195                        self.addColeta(Col_Hard(self.computador), self.decode(no.firstChild.nodeValue)) 
    196196                    elif no.nodeName == 'cs_coleta_monitorado': 
    197                         self.addColeta('col_moni', self.decode(no.firstChild.nodeValue)) 
     197                        #self.addColeta(None, self.decode(no.firstChild.nodeValue)) 
     198                        pass 
    198199                    elif no.nodeName == 'cs_coleta_software': 
    199                         self.addColeta('col_soft', self.decode(no.firstChild.nodeValue)) 
     200                        self.addColeta(Col_Soft(self.computador), self.decode(no.firstChild.nodeValue)) 
    200201                    elif no.nodeName == 'cs_coleta_unid_disc': 
    201                         self.addColeta('col_undi', self.decode(no.firstChild.nodeValue)) 
     202                        #self.addColeta(None, self.decode(no.firstChild.nodeValue)) 
     203                        pass 
    202204                    # VERSOES 
    203205                    elif no.nodeName == 'DT_VERSAO_CACIC2_DISPONIVEL': 
    …… 
    240242    def isNew(self, current, new): 
    241243        """Compara as versoes, atual com a disponivel.""" 
    242         return (current.replace('.','') < new.replace('.',''))    
    243  
     244        return (current.replace('.','') < new.replace('.','')) 
    244245     
    245246    def atualiza(self): 
    246247        """Atualiza os modulos dos coletores""" 
    247         # returns void 
    248248        """ 
    249249            TODO: definir como vai ficar a string de destino dos arquivos 
    …… 
    262262 
    263263    def startColeta(self): 
    264         """ Inicia as Coletas """ 
    265         # returns void 
    266         """ 
    267             TODO: Habilitar outras coletas alem do Col_Hard (apos as mesmas estarem prontas) 
    268         """ 
     264        """ Inicia as Coletas""" 
    269265        # limpa o dicionario da ultima coleta 
    270266        self.coletas_enviar.clear() 
    271267        self.computador.coletar() 
     268        # adiciona o coletor padrao (Col_Network) 
    272269        for col in self.coletores.values(): 
    273             if self.coleta_forcada or col.isReady(): 
    274                 col.start() 
     270            col.start() 
     271            if self.all_forcada or (col.getName() in self.coletas_forcadas) or col.isReady(self.OUTPUT_DAT):                 
    275272                page = Reader.getColetor(col.getName())['page'] 
    276273                dict = col.getEncryptedDict() 

  • cacic/trunk/agente-linux/pycacic/src/gui.py

    r427 r430  
    88import commands 
    99from ger_cols import * 
    10 from config.io import *  
     10from config.io import * 
     11from globals import Globals  
    1112 
    1213from socket import * 
    …… 
    1516class GUI: 
    1617 
    17     ICON_PATH = "%s/img/logo.png" % sys.path[0] 
    18     GLADE_PATH = '%s/glade/' % sys.path[0] 
     18    ICON_PATH = "%s/img/logo.png" % Globals.PATH 
     19    GLADE_PATH = '%s/glade/' % Globals.PATH 
    1920       
    2021    main_visible = False 
    …… 
    136137if __name__ == '__main__': 
    137138    try: 
     139        if not Globals.INSTALLED: 
     140            raise Exception("O PyCacic nao esta configurado, favor configura-lo.") 
    138141        GUI() 
    139142        gtk.main()