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 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 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
