def hallarIP(ID): """ Find all distinct IP from the exploration """ # Check if the IP have been already found yet conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('select ip_found from ip_found where analysis_id=%s limit 1;' % ID) aux = cursor.fetchall() cursor.close() conexion.close() # If not the I found it if not aux: stdout.write('\r\tFinding IP found: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('insert into ip_found select distinct(analysis_id), hop_ip from hops where analysis_id=%s;' % ID) conexion.commit() cursor.close() conexion.close() stdout.write('\r\tFinding IP found: Done\n') stdout.flush() return None
def hallarEnlacesIP(ID): """ Find IP links """ # Checking if links have been already found conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'SELECT IP1, IP2 FROM links_IP WHERE analysis_id=%s LIMIT 1;' % ID) aux = cursor.fetchall() cursor.close() conexion.close() # If not the I found it if not aux: stdout.write('\r\tFinding IP links: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'insert into links_IP select distinct(analysis_id), HOP_IP_previous, HOP_IP from hops where analysis_id=%s and HOP_IP_previous is not null and HOP_IP is not null;' % ID) conexion.commit() cursor.close() conexion.close() stdout.write('\r\tFinding IP links: Done\n') stdout.flush() return None
def hallarEnlacesIP(ID): """ Find IP links """ # Checking if links have been already found conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT IP1, IP2 FROM links_IP WHERE analysis_id=%s LIMIT 1;' % ID) aux = cursor.fetchall() cursor.close() conexion.close() # If not the I found it if not aux: stdout.write('\r\tFinding IP links: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('insert into links_IP select distinct(analysis_id), HOP_IP_previous, HOP_IP from hops where analysis_id=%s and HOP_IP_previous is not null and HOP_IP is not null;' % ID) conexion.commit() cursor.close() conexion.close() stdout.write('\r\tFinding IP links: Done\n') stdout.flush() return None
def hallarIP(ID): """ Find all distinct IP from the exploration """ # Check if the IP have been already found yet conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'select ip_found from ip_found where analysis_id=%s limit 1;' % ID) aux = cursor.fetchall() cursor.close() conexion.close() # If not the I found it if not aux: stdout.write('\r\tFinding IP found: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'insert into ip_found select distinct(analysis_id), hop_ip from hops where analysis_id=%s;' % ID) conexion.commit() cursor.close() conexion.close() stdout.write('\r\tFinding IP found: Done\n') stdout.flush() return None
def cargarConfiguracionMIDAR(midar_parametros): """ """ # Get the original configuration stdout.write('\n\r\tLoading configuration: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("""SELECT mper_port, mper_pps, est_duration, est_rounds, elim_rounds, cor_rounds, est_overlap, disc_overlap, elim_overlap, cor_overlap, cor_concurrency, elim_concurrency FROM alias_resolution where analysis_id=%s""" % midar_parametros.get('ID')) config = cursor.fetchall()[0] cursor.close() conexion.close() stdout.write('\r\tLoading configuration: Done\n') stdout.flush() # Apply configuration midar_parametros['config']['run_id'] = midar_parametros.get('ID') midar_parametros['config']['mper_port'] = config[0] midar_parametros['config']['mper_pps'] = config[1] midar_parametros['config']['est_duration'] = config[2] midar_parametros['config']['est_rounds'] = config[3] midar_parametros['config']['elim_rounds'] = config[4] midar_parametros['config']['cor_rounds'] = config[5] midar_parametros['config']['est_overlap'] = config[6] midar_parametros['config']['disc_overlap'] = config[7] midar_parametros['config']['elim_overlap'] = config[8] midar_parametros['config']['cor_overlap'] = config[9] midar_parametros['config']['elim_concurrency'] = config[10] midar_parametros['config']['cor_concurrency'] = config[11] return None
def registrar_ip_nodo(ID, nodo, archivo_direcciones): """ Write the IPs on each remote node """ try: # Read IP list archivo = open(archivo_direcciones) lista_ip = archivo.readlines() archivo.close() # Generate register datos = [(ID, nodo, ip.replace("\n", '')) for ip in lista_ip] # Writing table conexion = connect(conectar_BD()) cursor = conexion.cursor() query = """INSERT INTO ip_resolution (analysis_id, node, ip) VALUES (%s, %s, %s)""" cursor.executemany(query, datos) conexion.commit() cursor.close() conexion.close() except Exception as e: print 'ERROR: %s' % str(e) return None
def almacenarMetodoPreferido(ID): """ Store the prefered method of each IP based on the result of estimete stage of MIDAR """ try: archivo_resultados = [x for x in listdir('%s/temp' % directorio) if 'resultados__' in x] ip_metodo = set() # Read each file for x in archivo_resultados: archivo = open('%s/temp/%s' % (directorio, x)) resultado_aliases = archivo.readlines() archivo.close() # Get IP_METODO for x in resultado_aliases[2:-1]: x = x.split() if x[1][-1]=='*': ip_metodo.add((ID, x[0], x[1][0:-1])) # Write IP-METODO on ip_metodo_midar table conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.executemany("""INSERT INTO ip_metodo_midar (analysis_id, ip, metodo) VALUES (%s, %s, %s)""", ip_metodo) conexion.commit() cursor.close() conexion.close() except: resultado = False else: resultado = True return resultado
def registrar_ip_nodo(ID, nodo, archivo_direcciones): """ Write the IPs on each remote node """ try: # Read IP list archivo = open(archivo_direcciones) lista_ip = archivo.readlines() archivo.close() # Generate register datos = [(ID , nodo, ip.replace("\n", '')) for ip in lista_ip] # Writing table conexion = connect(conectar_BD()) cursor = conexion.cursor() query = """INSERT INTO ip_resolution (analysis_id, node, ip) VALUES (%s, %s, %s)""" cursor.executemany(query, datos) conexion.commit() cursor.close() conexion.close() except Exception as e: print 'ERROR: %s' % str(e) return None
def obtenerEstado(ID): """ Get resolution state of exploration <ID> """ conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT topology_state FROM analysis where analysis_id=%s;' % ID) estado = cursor.fetchall()[0][0] cursor.close() conexion.close() return estado
def obtenerEstado(ID): """ Get resolution state of exploration <ID> """ conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'SELECT topology_state FROM analysis where analysis_id=%s;' % ID) estado = cursor.fetchall()[0][0] cursor.close() conexion.close() return estado
def cargarUsuarios(usuarios): """ Take user from USERS table """ try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("""SELECT * FROM users;""") registros = cursor.fetchall() [usuarios.append({'usuario': x[0], 'password': x[1]}) for x in registros] cursor.close() conexion.close() except DatabaseError: print 'No users registered\n' return None
def eliminarArchivosTransferidos(midar_parametros, slice_name, opcion): """ Remove transferred files """ print 'Deleting files on remote nodes' try: conexion = connect(conectar_BD()) cursor = conexion.cursor() nodos_transferidos = midar_parametros.get(opcion) for nodo in nodos_transferidos: proceso = Popen(['parallel-ssh', '-H', nodo, '-l', slice_name, 'sudo rm /home/%s/%s/*' % (slice_name, midar_parametros.get('user'))], stdout=PIPE) proceso.stdout.close() cursor.execute("DELETE FROM ip_resolution WHERE analysis_id=%s and node='%s' " % (midar_parametros.get('ID'),nodo)) except Exception, e: print 'ERROR: %s' % str(e) conexion.rollback()
def buscar_ip_metodo(ID): """ Get the prefered method of each IP from ip_metodo_midar table """ conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT * FROM ip_metodo_midar where analysis_id=%s limit 1;' % ID) salida = cursor.fetchall() cursor.close() conexion.close() if len(salida): resultado = True else: resultado = False return resultado
def buscar_ip_metodo(ID): """ Get the prefered method of each IP from ip_metodo_midar table """ conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'SELECT * FROM ip_metodo_midar where analysis_id=%s limit 1;' % ID) salida = cursor.fetchall() cursor.close() conexion.close() if len(salida): resultado = True else: resultado = False return resultado
def generarNuevasListas(midar_parametros): """ Generate new list base on the probe type to use """ TCP = set() UDP = set() ICMP = set() indirect = set() sin_resolver = set() # Get IP-METODO pairs conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'SELECT IP, metodo FROM ip_metodo_midar WHERE analysis_id=%s;' % midar_parametros.get('ID')) salida = cursor.fetchall() cursor.close() conexion.close() # Assign each IP to their preferred method for x in salida: if x[1] == 'tcp': TCP.add(x[0]) elif x[1] == 'udp': UDP.add(x[0]) elif x[1] == 'icmp': ICMP.add(x[0]) elif x[1] == 'indirect': indirect.add(x[0]) else: sin_resolver.add(x[0]) # Generate new list base on the prefered method of each IP if TCP: generar_listas_v2(midar_parametros, TCP) if UDP: generar_listas_v2(midar_parametros, UDP) if ICMP: generar_listas_v2(midar_parametros, ICMP) if indirect: generar_listas_v2(midar_parametros, indirect) return None
def estadoNodos(midar_parametros, opcion, nodo): """ Manage nodes in alias resolution processes """ conexion = connect(conectar_BD()) cursor = conexion.cursor() ID = midar_parametros.get('ID') if opcion == 'reservar': cursor.execute("INSERT INTO nodes_working (node, analysis_id, work_type) VALUES ('%s', %s, '%s')" % (nodo, ID, 'MIDAR')) elif opcion == 'liberar': cursor.execute("DELETE FROM nodes_working WHERE analysis_id=%s and node='%s'" % (ID,nodo)) conexion.commit() cursor.close() conexion.close() return None
def darPrioridadNodos(nodos_midar): """ Prioritize nodes """ prioridad_por_defecto = 10 try: conexion = connect(conectar_BD()) cursor = conexion.cursor() # Read nodes in priority table cursor.execute('SELECT node FROM nodes_priority_for_AR;') try: aux = cursor.fetchall() nodos = [x[0] for x in aux] except: nodos = [] finally: # Get the nodes that are not in table nodos_insertar = set(nodos_midar) - set(nodos) # Add default priority to nodes which are not in the table if nodos_insertar: datos = [(nodo, prioridad_por_defecto) for nodo in nodos_insertar] else: datos = [] cursor.executemany( """INSERT INTO nodes_priority_for_AR (node, priority) VALUES (%s, %s)""", datos) conexion.commit() except DatabaseError as e: print 'Error: BD - %s' % e else: cursor.close() conexion.close() return None
def cargarUsuarios(usuarios): """ Take user from USERS table """ try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("""SELECT * FROM users;""") registros = cursor.fetchall() [ usuarios.append({ 'usuario': x[0], 'password': x[1] }) for x in registros ] cursor.close() conexion.close() except DatabaseError: print 'No users registered\n' return None
def generarNuevasListas(midar_parametros): """ Generate new list base on the probe type to use """ TCP = set() UDP = set() ICMP = set() indirect = set() sin_resolver = set() # Get IP-METODO pairs conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT IP, metodo FROM ip_metodo_midar WHERE analysis_id=%s;' % midar_parametros.get('ID')) salida = cursor.fetchall() cursor.close() conexion.close() # Assign each IP to their preferred method for x in salida: if x[1] == 'tcp': TCP.add(x[0]) elif x[1] == 'udp': UDP.add(x[0]) elif x[1] == 'icmp': ICMP.add(x[0]) elif x[1] == 'indirect': indirect.add(x[0]) else: sin_resolver.add(x[0]) # Generate new list base on the prefered method of each IP if TCP: generar_listas_v2(midar_parametros, TCP) if UDP: generar_listas_v2(midar_parametros, UDP) if ICMP: generar_listas_v2(midar_parametros, ICMP) if indirect: generar_listas_v2(midar_parametros, indirect) return None
def darPrioridadNodos(nodos_midar): """ Prioritize nodes """ prioridad_por_defecto = 10 try: conexion = connect(conectar_BD()) cursor = conexion.cursor() # Read nodes in priority table cursor.execute('SELECT node FROM nodes_priority_for_AR;') try: aux = cursor.fetchall() nodos = [x[0] for x in aux] except: nodos = [] finally: # Get the nodes that are not in table nodos_insertar = set(nodos_midar) - set(nodos) # Add default priority to nodes which are not in the table if nodos_insertar: datos = [(nodo, prioridad_por_defecto) for nodo in nodos_insertar] else: datos = [] cursor.executemany("""INSERT INTO nodes_priority_for_AR (node, priority) VALUES (%s, %s)""", datos) conexion.commit() except DatabaseError as e: print 'Error: BD - %s' % e else: cursor.close() conexion.close() return None
def obtenerNodosUtilizables(): """ Get useful nodes to alias resolution process, ordered by priority """ try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT node FROM nodes_priority_for_AR WHERE priority<>0 AND node not in (SELECT node FROM nodes_working) order by priority;') try: aux = cursor.fetchall() nodos = [x[0] for x in aux] except: nodos = [] cursor.close() conexion.close() except DatabaseError as e: print 'Error: %s' % str(e) nodos = [] return nodos
def estadoNodos(midar_parametros, opcion, nodo): """ Manage nodes in alias resolution processes """ conexion = connect(conectar_BD()) cursor = conexion.cursor() ID = midar_parametros.get('ID') if opcion == 'reservar': cursor.execute( "INSERT INTO nodes_working (node, analysis_id, work_type) VALUES ('%s', %s, '%s')" % (nodo, ID, 'MIDAR')) elif opcion == 'liberar': cursor.execute( "DELETE FROM nodes_working WHERE analysis_id=%s and node='%s'" % (ID, nodo)) conexion.commit() cursor.close() conexion.close() return None
def eliminarArchivosTransferidos(midar_parametros, slice_name, opcion): """ Remove transferred files """ print 'Deleting files on remote nodes' try: conexion = connect(conectar_BD()) cursor = conexion.cursor() nodos_transferidos = midar_parametros.get(opcion) for nodo in nodos_transferidos: proceso = Popen([ 'parallel-ssh', '-H', nodo, '-l', slice_name, 'sudo rm /home/%s/%s/*' % (slice_name, midar_parametros.get('user')) ], stdout=PIPE) proceso.stdout.close() cursor.execute( "DELETE FROM ip_resolution WHERE analysis_id=%s and node='%s' " % (midar_parametros.get('ID'), nodo)) except Exception, e: print 'ERROR: %s' % str(e) conexion.rollback()
def cargarConfiguracionMIDAR(midar_parametros): """ """ # Get the original configuration stdout.write('\n\r\tLoading configuration: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( """SELECT mper_port, mper_pps, est_duration, est_rounds, elim_rounds, cor_rounds, est_overlap, disc_overlap, elim_overlap, cor_overlap, cor_concurrency, elim_concurrency FROM alias_resolution where analysis_id=%s""" % midar_parametros.get('ID')) config = cursor.fetchall()[0] cursor.close() conexion.close() stdout.write('\r\tLoading configuration: Done\n') stdout.flush() # Apply configuration midar_parametros['config']['run_id'] = midar_parametros.get('ID') midar_parametros['config']['mper_port'] = config[0] midar_parametros['config']['mper_pps'] = config[1] midar_parametros['config']['est_duration'] = config[2] midar_parametros['config']['est_rounds'] = config[3] midar_parametros['config']['elim_rounds'] = config[4] midar_parametros['config']['cor_rounds'] = config[5] midar_parametros['config']['est_overlap'] = config[6] midar_parametros['config']['disc_overlap'] = config[7] midar_parametros['config']['elim_overlap'] = config[8] midar_parametros['config']['cor_overlap'] = config[9] midar_parametros['config']['elim_concurrency'] = config[10] midar_parametros['config']['cor_concurrency'] = config[11] return None
def obtenerNodosUtilizables(): """ Get useful nodes to alias resolution process, ordered by priority """ try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'SELECT node FROM nodes_priority_for_AR WHERE priority<>0 AND node not in (SELECT node FROM nodes_working) order by priority;' ) try: aux = cursor.fetchall() nodos = [x[0] for x in aux] except: nodos = [] cursor.close() conexion.close() except DatabaseError as e: print 'Error: %s' % str(e) nodos = [] return nodos
def lista_nodos_no_eliminables(): """ List of nodes which are not currently possible to remove """ try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("""SELECT nodes FROM analysis where stored='N';""") reg = cursor.fetchall() nodos = [] [nodos.extend(x[0].split()) for x in reg] nodos = list(set(nodos)) cursor.close() conexion.close() except IOError: pass except DatabaseError: pass return nodos
def almacenarMetodoPreferido(ID): """ Store the prefered method of each IP based on the result of estimete stage of MIDAR """ try: archivo_resultados = [ x for x in listdir('%s/temp' % directorio) if 'resultados__' in x ] ip_metodo = set() # Read each file for x in archivo_resultados: archivo = open('%s/temp/%s' % (directorio, x)) resultado_aliases = archivo.readlines() archivo.close() # Get IP_METODO for x in resultado_aliases[2:-1]: x = x.split() if x[1][-1] == '*': ip_metodo.add((ID, x[0], x[1][0:-1])) # Write IP-METODO on ip_metodo_midar table conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.executemany( """INSERT INTO ip_metodo_midar (analysis_id, ip, metodo) VALUES (%s, %s, %s)""", ip_metodo) conexion.commit() cursor.close() conexion.close() except: resultado = False else: resultado = True return resultado
def grabarEstado(midar_parametros, nuevo_estado): """ Save state of alias resolution process """ # List of possible states: # 0: Topology unresolved # 1: Solving topology on a single node -> Previo a estado final # 2: Running estimation state across multiple nodes -> Estado intermedio # 3: Solving topology across multiple nodes -> Previo a estado final # 4: Topology resolved # connecting to DB conexion = connect(conectar_BD()) cursor = conexion.cursor() # Update ANALYSIS table cursor.execute( "UPDATE analysis SET topology_state='%s' WHERE analysis_id=%s;" % (nuevo_estado, midar_parametros.get('ID'))) # Update ALIAS_RESOLUTION table if nuevo_estado in ('1', '2'): query = """INSERT INTO alias_resolution( analysis_id, estado, nodes, mper_port, mper_pps, est_duration, est_rounds, elim_rounds, cor_rounds, est_overlap, disc_overlap, elim_overlap, cor_overlap, cor_concurrency, elim_concurrency, TS) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""" datos = [] datos.append((int(midar_parametros.get('ID')), nuevo_estado, ' '.join(midar_parametros.get('nodos_elegidos')), int(midar_parametros.get('config').get('mper_port')), int(midar_parametros.get('config').get('mper_pps')), int(midar_parametros.get('config').get('est_duration')), int(midar_parametros.get('config').get('est_rounds')), int(midar_parametros.get('config').get('elim_rounds')), int(midar_parametros.get('config').get('cor_rounds')), int(midar_parametros.get('config').get('est_overlap')), int(midar_parametros.get('config').get('disc_overlap')), int(midar_parametros.get('config').get('elim_overlap')), int(midar_parametros.get('config').get('cor_overlap')), midar_parametros.get('config').get('cor_concurrency'), midar_parametros.get('config').get('elim_concurrency'), asctime(gmtime(int(time()))))) cursor.executemany(query, datos) elif nuevo_estado == '3': cursor.execute( "UPDATE alias_resolution SET (estado, nodes) =('%s', '%s') WHERE analysis_id=%s;" % (nuevo_estado, ' '.join(midar_parametros.get('nodos_elegidos')), midar_parametros.get('ID'))) elif nuevo_estado == '4': cursor.execute( "UPDATE alias_resolution SET estado='%s' WHERE analysis_id=%s;" % (nuevo_estado, midar_parametros.get('ID'))) conexion.commit() cursor.close() conexion.close() return None
def programarResolucionAliases(ID, api_server, auth, slice_name, nodos_midar, estado): """ main function in alias resolution process """ # START print '\nAlias resolution\n' # Define the dictionary to store parameters used midar_parametros = {} midar_parametros['ID'] = str(ID) midar_parametros['user'] = auth.get('Username') midar_parametros['nodos_elegidos'] = set( ) # Nodes where alias resolution process will run midar_parametros['IPs'] = set() # IPs to resolve midar_parametros['nombre_lista'] = [] midar_parametros['config'] = {} hallarIP(midar_parametros.get('ID')) hallarEnlacesIP(midar_parametros.get('ID')) if estado == '0': # Get the number of IPs to resolve stdout.write('\r\tLoading IPs: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('select ip_found from ip_found where analysis_id=%s;' % midar_parametros.get('ID')) [midar_parametros['IPs'].add(x[0]) for x in cursor] cursor.close() conexion.close() stdout.write('\r\tLoading IPs: %d \n' % len(midar_parametros.get('IPs'))) stdout.flush() if True: # Removing files in Temp folder vaciarTemp() # Generting list of IP to resolver in remote nodes generarListas(midar_parametros, midar_parametros.get('IPs')) # Setting MIDAR configuracion_MIDAR(midar_parametros) if confirmar('Start process'): try: # Transfering list to nodes transferirArchivos(midar_parametros, slice_name) except IndexError: print 'There is not enough not available nodes' eliminarArchivosTransferidos(midar_parametros, slice_name, 'nodos_elegidos') except Exception, e: print 'Error:\n', str(e) eliminarArchivosTransferidos(midar_parametros, slice_name, 'nodos_elegidos') else: ### Selecting method based on number of list generated previously try: if len(midar_parametros.get('nombre_lista')) == 1: if iniciarProceso(midar_parametros, slice_name, 'final'): grabarEstado(midar_parametros, '1') else: if iniciarProceso(midar_parametros, slice_name, 'estimacion'): grabarEstado(midar_parametros, '2') except Exception as e: print 'Error:\n', str(e) raise finally: vaciarTemp()
def comprobarResultadosPendientes(midar_parametros, slice_name, estado): """ Check if there are pending results """ user = midar_parametros.get('user') ID = midar_parametros.get('ID') # Checking if there are registers in ip_resolution table conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT ip FROM ip_resolution WHERE analysis_id=%s;' % ID) aux = cursor.fetchall() lista_ip = [x[0] for x in aux] cursor.execute('SELECT distinct(node) FROM ip_resolution WHERE analysis_id=%s;' % ID) aux = cursor.fetchall() lista_nodos = [x[0] for x in aux] cursor.close() conexion.close() # IF there are then ask if reprocess or not if lista_ip: continuar = False print '\nQuedan IP sin resolver: ' if confirmar('Reprocesar'): # Delete process in node for nodo in lista_nodos: eliminarResultadosNodos(slice_name, user, nodo) estadoNodos(midar_parametros, 'liberar', nodo) # Reprocess IPs conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("DELETE FROM ip_resolution WHERE analysis_id=%s" % ID) conexion.commit() cursor.close() conexion.close() vaciarTemp() generarListas(midar_parametros, lista_ip) cargarConfiguracionMIDAR(midar_parametros) transferirArchivos(midar_parametros, slice_name) if estado == '2': iniciarProceso(midar_parametros, slice_name, 'estimacion') else: iniciarProceso(midar_parametros, slice_name, 'final') conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("UPDATE alias_resolution SET (estado, nodes) = ('%s', '%s') WHERE analysis_id=%s;" % (estado, ' '.join(midar_parametros.get('nodos_elegidos')), ID )) conexion.commit() cursor.close() conexion.close() # else: continuar = True return continuar
def comprobarResultadosPendientes(midar_parametros, slice_name, estado): """ Check if there are pending results """ user = midar_parametros.get('user') ID = midar_parametros.get('ID') # Checking if there are registers in ip_resolution table conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT ip FROM ip_resolution WHERE analysis_id=%s;' % ID) aux = cursor.fetchall() lista_ip = [x[0] for x in aux] cursor.execute( 'SELECT distinct(node) FROM ip_resolution WHERE analysis_id=%s;' % ID) aux = cursor.fetchall() lista_nodos = [x[0] for x in aux] cursor.close() conexion.close() # IF there are then ask if reprocess or not if lista_ip: continuar = False print '\nQuedan IP sin resolver: ' if confirmar('Reprocesar'): # Delete process in node for nodo in lista_nodos: eliminarResultadosNodos(slice_name, user, nodo) estadoNodos(midar_parametros, 'liberar', nodo) # Reprocess IPs conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute("DELETE FROM ip_resolution WHERE analysis_id=%s" % ID) conexion.commit() cursor.close() conexion.close() vaciarTemp() generarListas(midar_parametros, lista_ip) cargarConfiguracionMIDAR(midar_parametros) transferirArchivos(midar_parametros, slice_name) if estado == '2': iniciarProceso(midar_parametros, slice_name, 'estimacion') else: iniciarProceso(midar_parametros, slice_name, 'final') conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( "UPDATE alias_resolution SET (estado, nodes) = ('%s', '%s') WHERE analysis_id=%s;" % (estado, ' '.join(midar_parametros.get('nodos_elegidos')), ID)) conexion.commit() cursor.close() conexion.close() # else: continuar = True return continuar
def descargarResultados(slice_name, midar_parametros): """ Download results """ ID = midar_parametros.get('ID') user= midar_parametros.get('user') resultado = True vaciarTemp() # Getting nodes where the process was installed try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT nodes FROM alias_resolution WHERE analysis_id=%s;' % ID) nodos = cursor.fetchall()[0][0] cursor.close() conexion.close() nodos = nodos.split() except Exception as e: print 'ERROR: %s' % str(e) resultado = False else: nodos_OK = set() nodos_KO = set() resultado = True try: print 'Getting results\n' conexion = connect(conectar_BD()) cursor = conexion.cursor() for nodo in nodos: print '\n\nNode: %s' % nodo archivo = '/home/%s/%s/resultados__%s__%s__.txt.gz' % (slice_name, user, ID, nodo) comando = 'scp %s@%s:%s %s/temp/' % (slice_name, nodo, archivo, directorio) call([comando], shell=True) if exists('%s/temp/resultados__%s__%s__.txt.gz' % (directorio, ID, nodo)): nodos_OK.add(nodo) proceso = Popen(['gzip -d %s/temp/resultados__%s__%s__.txt.gz' % (directorio, ID, nodo)], shell=True) proceso.wait() cursor.execute("DELETE FROM ip_resolution WHERE analysis_id=%s AND node='%s' " % (ID,nodo)) estadoNodos(midar_parametros, 'liberar', nodo) eliminarResultadosNodos(slice_name, user, nodo) else: nodos_KO.add(nodo) except Exception as e: print 'ERROR: %s' % str(e) conexion.rollback() resultado = False vaciarTemp() else: conexion.commit() if len(nodos_KO) == 0: print '\nAll results were correctly downloaded\n' print 'TOTAL: %s/%s' % (len(nodos_OK), len(nodos)) else: print '\nThere have been results without download:\n' print 'TOTAL: %s/%s' % (len(nodos_OK), len(nodos)) if confirmar('Discard results'): cursor.execute("DELETE FROM ip_resolution WHERE analysis_id=%s" % ID) conexion.commit() for nodo in nodos_KO: eliminarResultadosNodos(slice_name, user, nodo) estadoNodos(midar_parametros, 'liberar', nodo) nodos_KO.clear() finally: cursor.execute("UPDATE alias_resolution SET nodes='%s' WHERE analysis_id=%s;" % ( ' '.join(nodos_KO), ID )) conexion.commit() cursor.close() conexion.close() return resultado
def almacenarResultados(ID): """ Store results """ try: print '\nStoring results' conexion = connect(conectar_BD()) cursor = conexion.cursor() # Find MIDAR folder archivo_resultados = [x for x in listdir('%s/temp' % directorio) if 'resultados__' in x] # Analysis each result file for x in archivo_resultados: # Load result file archivo = open('%s/temp/%s' % (directorio, x)) resultado_aliases = archivo.readlines() archivo.close() remove('%s/temp/%s' % (directorio, x)) # Remove unnecessary lines resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases = ' '.join(resultado_aliases) resultado_aliases = resultado_aliases.split('#') resultado_aliases.pop(0) resultado_aliases.pop() datos = [] datos_int = [] # Find max router_id cursor.execute('SELECT max(router_id) FROM routers WHERE analysis_id=%s;' % ID) try: router_id = int(cursor.fetchone()[0]) except: router_id = 0 # Analysis each router for x in resultado_aliases: x = x.split('\n') header = x.pop(0) header = header.split() x.pop() try: router_id += 1 num_interfaces = int(header[2]) except: pass else: [datos_int.append((int(ID), router_id, ip.strip(' '))) for ip in x] datos.append((int(ID), router_id, num_interfaces)) # Store processed results query = """INSERT INTO routers (analysis_id, router_id, num_interfaces) VALUES (%s, %s, %s)""" cursor.executemany(query, datos) query = """INSERT INTO interfaces (analysis_id, router_id, IP ) VALUES (%s, %s, %s)""" cursor.executemany(query, datos_int) except Exception as e: print 'ERROR: %s' % str(e) conexion.rollback() resultado = False else: conexion.commit() resultado = True finally: cursor.close() conexion.close() return resultado
def resolverEnlaces(ID): """ Find the router links based on the results of alias resolution process """ stdout.write('\n\r\tFinding links:\t') stdout.flush() try: conexion = connect(conectar_BD()) cursor = conexion.cursor() # Getting max router_id cursor.execute('SELECT max(router_id) FROM routers WHERE analysis_id=%s;' % ID) try: max_router_id = int(cursor.fetchone()[0]) except: max_router_id = 1 # Loading in memory INTERFACE table tabla_interfaces = {} cursor.execute('SELECT ip, router_id FROM interfaces WHERE analysis_id=%s;' % ID) reg = cursor.fetchone() while reg: tabla_interfaces[reg[0]] = reg[1] reg = cursor.fetchone() # Finding out neighbour IPs cursor.execute('SELECT (IP1, IP2) FROM links_IP WHERE analysis_id=%s;' % ID) # Checking each pair of neighboring IPs enlaces = set() datos_routers = set() datos_interfaces = set() x = cursor.fetchone() while x: IP = x[0][1:-1].split(',') # Analyze each IP to get to each router belongs r1, max_router_id = asociar_IP_router(tabla_interfaces, ID, IP[0], max_router_id, datos_routers, datos_interfaces) r2, max_router_id = asociar_IP_router(tabla_interfaces, ID, IP[1], max_router_id, datos_routers, datos_interfaces) # Save the router link enlaces.add((int(ID), r1, r2)) # move to next link x = cursor.fetchone() # Insert new registers on ROUTER table query = """INSERT INTO routers (analysis_id, router_id, num_interfaces) VALUES (%s, %s, %s)""" cursor.executemany(query, list(datos_routers)) # Insert new registers on INTERFACES table query = """INSERT INTO interfaces (analysis_id, router_id, ip) VALUES (%s, %s, %s)""" cursor.executemany(query, list(datos_interfaces)) # Insert new registers on LINKS table query = """INSERT INTO links (analysis_id, R1, R2) VALUES (%s, %s, %s)""" cursor.executemany(query, list(enlaces)) conexion.commit() stdout.write('\r\tFinding links:\tLinks created') stdout.flush() cursor.close() conexion.close() except Exception as e: stdout.write('\r\tFinding links:\tERROR - %s' % e) stdout.flush() conexion.rollback() return None
def obtenerLocalizacionRouters(ID): """ Get location of each router """ stdout.write('\n\r\tGetting location of routers: ') stdout.flush() try: # Connecting to MaxMind DB reader = geoip2_reader(direccion_geolite) # Get ROUTER ID of analysis conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT router_id FROM routers WHERE analysis_id=%s;' % ID) RID = cursor.fetchall() except Exception as e: print '\nERROR: %s' % str(e) else: # Getting an interface for each router ID for x in RID: x = x[0] try: # Taking an IP to get its location cursor.execute('SELECT IP FROM interfaces WHERE analysis_id=%s AND router_id=%s limit 1;' % (ID, x)) IP = cursor.fetchone()[0] response = reader.city(IP) try: continent = str(response.continent.name) except UnicodeEncodeError: continent = None try: cod_continent = str(response.continent.code) except UnicodeEncodeError: cod_continent = None try: country = str(response.country.name) except UnicodeEncodeError: country = None try: cod_country = str(response.country.iso_code) except UnicodeEncodeError: cod_country = None try: region = str(response.subdivisions.most_specific.name) except UnicodeEncodeError: region = None try: cod_region = str(response.subdivisions.most_specific.iso_code) except UnicodeEncodeError: cod_region = None try: city = str(response.city.name) except UnicodeEncodeError: city = None try: latitude = float(response.location.latitude) except: latitude = None try: longitude = float(response.location.longitude) except: longitude = None localizacion = (continent, cod_continent, country, cod_country, region, cod_region, city, latitude, longitude) query = 'UPDATE routers SET (continent, cod_continent, country, cod_country, region, cod_region, city, latitude, longitude) = (%s, %s, %s, %s, %s, %s, %s, %s, %s) ' + 'WHERE analysis_id=%s AND router_id=%s;' % (ID, x) cursor.execute(query, localizacion) except Exception as e: conexion.rollback() else: conexion.commit() finally: stdout.write('\r\tGetting location of routers: Done') stdout.flush() reader.close() cursor.close() conexion.close() return None
def obtenerLocalizacionRouters(ID): """ Get location of each router """ stdout.write('\n\r\tGetting location of routers: ') stdout.flush() try: # Connecting to MaxMind DB reader = geoip2_reader(direccion_geolite) # Get ROUTER ID of analysis conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('SELECT router_id FROM routers WHERE analysis_id=%s;' % ID) RID = cursor.fetchall() except Exception as e: print '\nERROR: %s' % str(e) else: # Getting an interface for each router ID for x in RID: x = x[0] try: # Taking an IP to get its location cursor.execute( 'SELECT IP FROM interfaces WHERE analysis_id=%s AND router_id=%s limit 1;' % (ID, x)) IP = cursor.fetchone()[0] response = reader.city(IP) try: continent = str(response.continent.name) except UnicodeEncodeError: continent = None try: cod_continent = str(response.continent.code) except UnicodeEncodeError: cod_continent = None try: country = str(response.country.name) except UnicodeEncodeError: country = None try: cod_country = str(response.country.iso_code) except UnicodeEncodeError: cod_country = None try: region = str(response.subdivisions.most_specific.name) except UnicodeEncodeError: region = None try: cod_region = str( response.subdivisions.most_specific.iso_code) except UnicodeEncodeError: cod_region = None try: city = str(response.city.name) except UnicodeEncodeError: city = None try: latitude = float(response.location.latitude) except: latitude = None try: longitude = float(response.location.longitude) except: longitude = None localizacion = (continent, cod_continent, country, cod_country, region, cod_region, city, latitude, longitude) query = 'UPDATE routers SET (continent, cod_continent, country, cod_country, region, cod_region, city, latitude, longitude) = (%s, %s, %s, %s, %s, %s, %s, %s, %s) ' + 'WHERE analysis_id=%s AND router_id=%s;' % ( ID, x) cursor.execute(query, localizacion) except Exception as e: conexion.rollback() else: conexion.commit() finally: stdout.write('\r\tGetting location of routers: Done') stdout.flush() reader.close() cursor.close() conexion.close() return None
def programarResolucionAliases(ID, api_server, auth, slice_name, nodos_midar, estado): """ main function in alias resolution process """ # START print '\nAlias resolution\n' # Define the dictionary to store parameters used midar_parametros = {} midar_parametros['ID'] = str(ID) midar_parametros['user'] = auth.get('Username') midar_parametros['nodos_elegidos'] = set() # Nodes where alias resolution process will run midar_parametros['IPs'] = set() # IPs to resolve midar_parametros['nombre_lista'] = [] midar_parametros['config'] = {} hallarIP(midar_parametros.get('ID')) hallarEnlacesIP(midar_parametros.get('ID')) if estado == '0': # Get the number of IPs to resolve stdout.write('\r\tLoading IPs: ') stdout.flush() conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('select ip_found from ip_found where analysis_id=%s;' % midar_parametros.get('ID')) [midar_parametros['IPs'].add(x[0]) for x in cursor] cursor.close() conexion.close() stdout.write('\r\tLoading IPs: %d \n' % len(midar_parametros.get('IPs'))) stdout.flush() if True: # Removing files in Temp folder vaciarTemp() # Generting list of IP to resolver in remote nodes generarListas(midar_parametros, midar_parametros.get('IPs')) # Setting MIDAR configuracion_MIDAR(midar_parametros) if confirmar('Start process'): try: # Transfering list to nodes transferirArchivos(midar_parametros, slice_name) except IndexError: print 'There is not enough not available nodes' eliminarArchivosTransferidos(midar_parametros, slice_name, 'nodos_elegidos') except Exception, e: print 'Error:\n', str(e) eliminarArchivosTransferidos(midar_parametros, slice_name, 'nodos_elegidos') else: ### Selecting method based on number of list generated previously try: if len(midar_parametros.get('nombre_lista')) == 1: if iniciarProceso(midar_parametros, slice_name, 'final'): grabarEstado(midar_parametros, '1') else: if iniciarProceso(midar_parametros, slice_name, 'estimacion'): grabarEstado(midar_parametros, '2') except Exception as e: print 'Error:\n', str(e) raise finally: vaciarTemp()
def resolverEnlaces(ID): """ Find the router links based on the results of alias resolution process """ stdout.write('\n\r\tFinding links:\t') stdout.flush() try: conexion = connect(conectar_BD()) cursor = conexion.cursor() # Getting max router_id cursor.execute( 'SELECT max(router_id) FROM routers WHERE analysis_id=%s;' % ID) try: max_router_id = int(cursor.fetchone()[0]) except: max_router_id = 1 # Loading in memory INTERFACE table tabla_interfaces = {} cursor.execute( 'SELECT ip, router_id FROM interfaces WHERE analysis_id=%s;' % ID) reg = cursor.fetchone() while reg: tabla_interfaces[reg[0]] = reg[1] reg = cursor.fetchone() # Finding out neighbour IPs cursor.execute( 'SELECT (IP1, IP2) FROM links_IP WHERE analysis_id=%s;' % ID) # Checking each pair of neighboring IPs enlaces = set() datos_routers = set() datos_interfaces = set() x = cursor.fetchone() while x: IP = x[0][1:-1].split(',') # Analyze each IP to get to each router belongs r1, max_router_id = asociar_IP_router(tabla_interfaces, ID, IP[0], max_router_id, datos_routers, datos_interfaces) r2, max_router_id = asociar_IP_router(tabla_interfaces, ID, IP[1], max_router_id, datos_routers, datos_interfaces) # Save the router link enlaces.add((int(ID), r1, r2)) # move to next link x = cursor.fetchone() # Insert new registers on ROUTER table query = """INSERT INTO routers (analysis_id, router_id, num_interfaces) VALUES (%s, %s, %s)""" cursor.executemany(query, list(datos_routers)) # Insert new registers on INTERFACES table query = """INSERT INTO interfaces (analysis_id, router_id, ip) VALUES (%s, %s, %s)""" cursor.executemany(query, list(datos_interfaces)) # Insert new registers on LINKS table query = """INSERT INTO links (analysis_id, R1, R2) VALUES (%s, %s, %s)""" cursor.executemany(query, list(enlaces)) conexion.commit() stdout.write('\r\tFinding links:\tLinks created') stdout.flush() cursor.close() conexion.close() except Exception as e: stdout.write('\r\tFinding links:\tERROR - %s' % e) stdout.flush() conexion.rollback() return None
def grabarEstado(midar_parametros, nuevo_estado): """ Save state of alias resolution process """ # List of possible states: # 0: Topology unresolved # 1: Solving topology on a single node -> Previo a estado final # 2: Running estimation state across multiple nodes -> Estado intermedio # 3: Solving topology across multiple nodes -> Previo a estado final # 4: Topology resolved # connecting to DB conexion = connect(conectar_BD()) cursor = conexion.cursor() # Update ANALYSIS table cursor.execute("UPDATE analysis SET topology_state='%s' WHERE analysis_id=%s;" % (nuevo_estado, midar_parametros.get('ID') )) # Update ALIAS_RESOLUTION table if nuevo_estado in ('1', '2'): query = """INSERT INTO alias_resolution( analysis_id, estado, nodes, mper_port, mper_pps, est_duration, est_rounds, elim_rounds, cor_rounds, est_overlap, disc_overlap, elim_overlap, cor_overlap, cor_concurrency, elim_concurrency, TS) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)""" datos = [] datos.append(( int(midar_parametros.get('ID')), nuevo_estado, ' '.join(midar_parametros.get('nodos_elegidos')), int(midar_parametros.get('config').get('mper_port')), int(midar_parametros.get('config').get('mper_pps')), int(midar_parametros.get('config').get('est_duration')), int(midar_parametros.get('config').get('est_rounds')), int(midar_parametros.get('config').get('elim_rounds')), int(midar_parametros.get('config').get('cor_rounds')), int(midar_parametros.get('config').get('est_overlap')), int(midar_parametros.get('config').get('disc_overlap')), int(midar_parametros.get('config').get('elim_overlap')), int(midar_parametros.get('config').get('cor_overlap')), midar_parametros.get('config').get('cor_concurrency'), midar_parametros.get('config').get('elim_concurrency'), asctime(gmtime(int(time()))))) cursor.executemany(query, datos) elif nuevo_estado == '3': cursor.execute("UPDATE alias_resolution SET (estado, nodes) =('%s', '%s') WHERE analysis_id=%s;" % (nuevo_estado, ' '.join(midar_parametros.get('nodos_elegidos')), midar_parametros.get('ID') )) elif nuevo_estado == '4': cursor.execute("UPDATE alias_resolution SET estado='%s' WHERE analysis_id=%s;" % (nuevo_estado, midar_parametros.get('ID') )) conexion.commit() cursor.close() conexion.close() return None
def descargarResultados(slice_name, midar_parametros): """ Download results """ ID = midar_parametros.get('ID') user = midar_parametros.get('user') resultado = True vaciarTemp() # Getting nodes where the process was installed try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute( 'SELECT nodes FROM alias_resolution WHERE analysis_id=%s;' % ID) nodos = cursor.fetchall()[0][0] cursor.close() conexion.close() nodos = nodos.split() except Exception as e: print 'ERROR: %s' % str(e) resultado = False else: nodos_OK = set() nodos_KO = set() resultado = True try: print 'Getting results\n' conexion = connect(conectar_BD()) cursor = conexion.cursor() for nodo in nodos: print '\n\nNode: %s' % nodo archivo = '/home/%s/%s/resultados__%s__%s__.txt.gz' % ( slice_name, user, ID, nodo) comando = 'scp %s@%s:%s %s/temp/' % (slice_name, nodo, archivo, directorio) call([comando], shell=True) if exists('%s/temp/resultados__%s__%s__.txt.gz' % (directorio, ID, nodo)): nodos_OK.add(nodo) proceso = Popen([ 'gzip -d %s/temp/resultados__%s__%s__.txt.gz' % (directorio, ID, nodo) ], shell=True) proceso.wait() cursor.execute( "DELETE FROM ip_resolution WHERE analysis_id=%s AND node='%s' " % (ID, nodo)) estadoNodos(midar_parametros, 'liberar', nodo) eliminarResultadosNodos(slice_name, user, nodo) else: nodos_KO.add(nodo) except Exception as e: print 'ERROR: %s' % str(e) conexion.rollback() resultado = False vaciarTemp() else: conexion.commit() if len(nodos_KO) == 0: print '\nAll results were correctly downloaded\n' print 'TOTAL: %s/%s' % (len(nodos_OK), len(nodos)) else: print '\nThere have been results without download:\n' print 'TOTAL: %s/%s' % (len(nodos_OK), len(nodos)) if confirmar('Discard results'): cursor.execute( "DELETE FROM ip_resolution WHERE analysis_id=%s" % ID) conexion.commit() for nodo in nodos_KO: eliminarResultadosNodos(slice_name, user, nodo) estadoNodos(midar_parametros, 'liberar', nodo) nodos_KO.clear() finally: cursor.execute( "UPDATE alias_resolution SET nodes='%s' WHERE analysis_id=%s;" % (' '.join(nodos_KO), ID)) conexion.commit() cursor.close() conexion.close() return resultado
def menuUsuarios(api_server, auth): """ User menu """ while True: print color.UNDERLINE + '\nUser menu:' + color.END print '1: Users' print '2: Manual' print '3: Options' print '*: Exit' opcion = raw_input('\nOption: ') print '\n' if opcion == '1': # User try: volver = True try: usuarios = [] cargarUsuarios(usuarios) except: print "Loading problems users" else: if usuarios: print color.UNDERLINE + 'User:'******': ', x.get('usuario') while True: user_number = raw_input('\nSelect user:'******'Username'] = x.get('usuario') auth['AuthString'] = x.get( 'password') auth['AuthMethod'] = "password" volver = False continuar = True break n += 1 break else: print "Wrong user" else: print "Error logging user" if volver == False: break except KeyboardInterrupt: pass elif opcion == '2': # Manual entry try: auth['Username'] = raw_input('Entry user:\t') auth['AuthString'] = getpass('Entry pass:\t') auth['AuthMethod'] = "password" continuar = True break except KeyboardInterrupt: pass elif opcion == '3': # User options while True: print color.UNDERLINE + 'User menu: User options:' + color.END print '1: View users' print '2: Add new user' print '3: Remove user' print '*: Exit' opt2 = raw_input('\nOption: ') if opt2 == '1': # View users try: usuarios = [] cargarUsuarios(usuarios) except Exception as e: print 'ERROR: %s' % str(e) else: if usuarios: print '\nCurrent users:' n = 0 for x in usuarios: n += 1 print n, ': ', x.get('usuario') print '\n' elif opt2 == '2': # Add new user print '\nEntry data (* to return):\n' Username = raw_input('User:\t') if Username != '*': AuthString = getpass('Pass:\t') auth['Username'] = Username auth['AuthString'] = AuthString auth['AuthMethod'] = "password" if verificarUsuario(api_server, auth): try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('INSERT INTO users VALUES ' + str((Username, AuthString)) + ';') conexion.commit() cursor.close() conexion.close() except DatabaseError as e: print '\nError: %s' % str(e) else: print '\nNew user added successfully\n' else: print '\nThe user was not validated by PlanetLab\n' elif opt2 == '3': # Remove user try: usuarios = [] cargarUsuarios(usuarios) except Exception as e: print 'ERROR: %s' % str(e) else: if usuarios: print '\nCurrent users:' cant_usuarios = len(usuarios) n = 0 for x in usuarios: n += 1 print n, ': ', x.get('usuario') while True: user_number = raw_input( '\nUser to remove (* to return): ') if user_number == '*': break elif user_number.isdigit(): user_number = int(user_number) if user_number >= 1 and user_number <= cant_usuarios: try: conexion = connect(conectar_BD()) cursor = conexion.cursor() aux = usuarios[user_number - 1] cursor.execute( 'DELETE FROM users WHERE usr=\'' + str(aux.get('usuario')) + '\';') conexion.commit() cursor.close() conexion.close() except DatabaseError as e: print '\nError: %s' % str(e) break else: print '\nUser removed successfully\n' break else: print 'Wrong' else: print 'Wrong' elif opt2 == '*': # Return break elif opcion == '*': # Ending program auth['Username'] = '' auth['AuthString'] = '' auth['AuthMethod'] = "password" continuar = False break return continuar
def almacenarResultados(ID): """ Store results """ try: print '\nStoring results' conexion = connect(conectar_BD()) cursor = conexion.cursor() # Find MIDAR folder archivo_resultados = [ x for x in listdir('%s/temp' % directorio) if 'resultados__' in x ] # Analysis each result file for x in archivo_resultados: # Load result file archivo = open('%s/temp/%s' % (directorio, x)) resultado_aliases = archivo.readlines() archivo.close() remove('%s/temp/%s' % (directorio, x)) # Remove unnecessary lines resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases.pop(0) resultado_aliases = ' '.join(resultado_aliases) resultado_aliases = resultado_aliases.split('#') resultado_aliases.pop(0) resultado_aliases.pop() datos = [] datos_int = [] # Find max router_id cursor.execute( 'SELECT max(router_id) FROM routers WHERE analysis_id=%s;' % ID) try: router_id = int(cursor.fetchone()[0]) except: router_id = 0 # Analysis each router for x in resultado_aliases: x = x.split('\n') header = x.pop(0) header = header.split() x.pop() try: router_id += 1 num_interfaces = int(header[2]) except: pass else: [ datos_int.append((int(ID), router_id, ip.strip(' '))) for ip in x ] datos.append((int(ID), router_id, num_interfaces)) # Store processed results query = """INSERT INTO routers (analysis_id, router_id, num_interfaces) VALUES (%s, %s, %s)""" cursor.executemany(query, datos) query = """INSERT INTO interfaces (analysis_id, router_id, IP ) VALUES (%s, %s, %s)""" cursor.executemany(query, datos_int) except Exception as e: print 'ERROR: %s' % str(e) conexion.rollback() resultado = False else: conexion.commit() resultado = True finally: cursor.close() conexion.close() return resultado
def menuUsuarios(api_server, auth): """ User menu """ while True: print color.UNDERLINE + '\nUser menu:' + color.END print '1: Users' print '2: Manual' print '3: Options' print '*: Exit' opcion = raw_input('\nOption: ') print '\n' if opcion == '1': # User try: volver = True try: usuarios = [] cargarUsuarios(usuarios) except: print "Loading problems users" else: if usuarios: print color.UNDERLINE + 'User:'******': ', x.get('usuario') while True: user_number = raw_input('\nSelect user:'******'Username'] = x.get('usuario') auth['AuthString'] = x.get('password') auth['AuthMethod'] = "password" volver = False continuar = True break n += 1 break else: print "Wrong user" else: print "Error logging user" if volver == False: break except KeyboardInterrupt: pass elif opcion == '2': # Manual entry try: auth['Username'] = raw_input('Entry user:\t') auth['AuthString'] = getpass('Entry pass:\t') auth['AuthMethod'] = "password" continuar = True break except KeyboardInterrupt: pass elif opcion == '3': # User options while True: print color.UNDERLINE + 'User menu: User options:' + color.END print '1: View users' print '2: Add new user' print '3: Remove user' print '*: Exit' opt2 = raw_input('\nOption: ') if opt2 == '1': # View users try: usuarios = [] cargarUsuarios(usuarios) except Exception as e: print 'ERROR: %s' % str(e) else: if usuarios: print '\nCurrent users:' n = 0 for x in usuarios: n += 1 print n, ': ', x.get('usuario') print '\n' elif opt2 == '2': # Add new user print '\nEntry data (* to return):\n' Username = raw_input('User:\t') if Username != '*': AuthString = getpass('Pass:\t') auth['Username'] = Username auth['AuthString'] = AuthString auth['AuthMethod'] = "password" if verificarUsuario(api_server, auth): try: conexion = connect(conectar_BD()) cursor = conexion.cursor() cursor.execute('INSERT INTO users VALUES ' + str((Username, AuthString)) + ';') conexion.commit() cursor.close() conexion.close() except DatabaseError as e: print '\nError: %s' % str(e) else: print '\nNew user added successfully\n' else: print '\nThe user was not validated by PlanetLab\n' elif opt2 == '3': # Remove user try: usuarios = [] cargarUsuarios(usuarios) except Exception as e: print 'ERROR: %s' % str(e) else: if usuarios: print '\nCurrent users:' cant_usuarios = len(usuarios) n = 0 for x in usuarios: n += 1 print n, ': ', x.get('usuario') while True: user_number = raw_input('\nUser to remove (* to return): ') if user_number == '*': break elif user_number.isdigit(): user_number = int(user_number) if user_number >= 1 and user_number <= cant_usuarios: try: conexion = connect(conectar_BD()) cursor = conexion.cursor() aux = usuarios[user_number-1] cursor.execute('DELETE FROM users WHERE usr=\''+ str(aux.get('usuario')) +'\';') conexion.commit() cursor.close() conexion.close() except DatabaseError as e: print '\nError: %s' % str(e) break else: print '\nUser removed successfully\n' break else: print 'Wrong' else: print 'Wrong' elif opt2 == '*': # Return break elif opcion == '*': # Ending program auth['Username'] = '' auth['AuthString'] = '' auth['AuthMethod'] = "password" continuar = False break return continuar