Writing to the database works now.

This commit is contained in:
kalzu rekku 2024-05-27 22:37:47 +03:00
parent 6e9d11dcde
commit 929a3523ba

View File

@ -6,8 +6,11 @@ import sqlite3
import re import re
import json import json
import ipaddress import ipaddress
import uuid
import hashlib
from datetime import datetime from datetime import datetime
def run_traceroute(host): def run_traceroute(host):
timestamp = datetime.now().timestamp() timestamp = datetime.now().timestamp()
result = subprocess.run(['traceroute', host], stdout=subprocess.PIPE) result = subprocess.run(['traceroute', host], stdout=subprocess.PIPE)
@ -16,6 +19,7 @@ def run_traceroute(host):
def parse_traceroute_output(output, timestamp): def parse_traceroute_output(output, timestamp):
lines = output.strip().split('\n') lines = output.strip().split('\n')
trace = {}
hops = [] hops = []
ip_regex = r"\((.*?)\)" # ipaddress are in () ip_regex = r"\((.*?)\)" # ipaddress are in ()
@ -40,7 +44,8 @@ def parse_traceroute_output(output, timestamp):
# source node drops or blocks icmp packages # source node drops or blocks icmp packages
# We will give funny to name to hop for not answering and move on. # We will give funny to name to hop for not answering and move on.
if part == '*': if part == '*':
hop_name = 'hop.'+str(count)+'.'+str(target) hop_name = 'unresponsive'
hop_ip = 'unresponsive'
break break
@ -73,17 +78,18 @@ def parse_traceroute_output(output, timestamp):
hop_latency = sum(latencies) / len(latencies) if latencies else None hop_latency = sum(latencies) / len(latencies) if latencies else None
hop['timestamp'] = timestamp
hop['hop_number'] = hop_number hop['hop_number'] = hop_number
if not hop_name == None: if not hop_name == None:
hop['hop_name'] = hop_name hop['hop_name'] = hop_name
hop['hop_ip'] = hop_ip hop['hop_ip'] = hop_ip
hop['hop_latency'] = hop_latency hop['hop_latency'] = hop_latency
hops.append(target)
hops.append(hop) hops.append(hop)
return hops trace['target'] = target
trace['timestamp'] = timestamp
trace['hops'] = hops
return trace
def create_tables(databasefile): def create_tables(databasefile):
@ -104,10 +110,10 @@ def create_tables(databasefile):
create_paths_table = """ create_paths_table = """
CREATE TABLE IF NOT EXISTS Paths ( CREATE TABLE IF NOT EXISTS Paths (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
start_ip TEXT NOT NULL, node TEXT NOT NULL,
end_ip TEXT NOT NULL, target TEXT NOT NULL,
hops_json TEXT NOT NULL, hops_json TEXT NOT NULL,
UNIQUE(start_ip, end_ip, hops_json) UNIQUE(node, target, hops_json)
); );
""" """
@ -124,12 +130,9 @@ def create_tables(databasefile):
create_hopdetails_table = """ create_hopdetails_table = """
CREATE TABLE IF NOT EXISTS HopDetails ( CREATE TABLE IF NOT EXISTS HopDetails (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
link_id INTEGER NOT NULL, hop_name TEXT,
ttl INTEGER, hop_ip TEXT,
icmp_type INTEGER, hop_latency TEXT
icmp_code INTEGER,
packet_loss REAL,
FOREIGN KEY (link_id) REFERENCES Links(id)
); );
""" """
@ -143,70 +146,101 @@ def create_tables(databasefile):
conn.commit() conn.commit()
conn.close() conn.close()
def store_traceroute(db_file, start_ip, end_ip, hops): def store_traceroute(db_file, node, trace):
conn = sqlite3.connect(db_file) conn = sqlite3.connect(db_file)
cursor = conn.cursor() cursor = conn.cursor()
# Insert links and get their IDs
link_ids = []
for hop in hops:
print(hop)
source_ip = start_ip if not link_ids else hops[len(link_ids)-1][0]
destination_ip = hop[0]
latency = hop[1]
cursor.execute(""" hops_json = json.dumps(trace['hops'])
INSERT OR IGNORE INTO Links (source_ip, destination_ip) VALUES (?, ?)
""", (source_ip, destination_ip))
cursor.execute("""
SELECT id FROM Links WHERE source_ip = ? AND destination_ip = ?
""", (source_ip, destination_ip))
result = cursor.fetchone()
if result is None:
print(hop)
raise ValueError(f"Failed to insert of find link between {source_ip} and {destination_ip}")
link_id = result[0]
link_ids.append(link_id)
cursor.execute(""" path_ids = {}
INSERT INTO Latency (link_id, latency_ms) VALUES (?, ?)
""", (link_id, latency))
# Insert path previous_hop_ip = None
hops_json = json.dumps(link_ids) previous_hop_latency = None
cursor.execute(""" for hop in trace['hops']:
INSERT INTO Paths (start_ip, end_ip, hops_json) VALUES (?, ?, ?) hop_number = hop['hop_number']
""", (start_ip, end_ip, hops_json)) hop_name = hop.get('hop_name')
hop_ip = hop.get('hop_ip')
hop_latency = hop.get('hop_latency')
link_id = None
# insert links and get their id's
if previous_hop_ip:
cursor.execute("""
INSERT OR IGNORE INTO Links (source_ip, destination_ip) VALUES (?, ?)
""", (previous_hop_ip, hop_ip))
cursor.execute("""
SELECT id FROM Links WHERE source_ip = ? AND destination_ip = ?
""", (previous_hop_ip, hop_ip))
result = cursor.fetchone()
link_id = result
path_ids[hop_number] = link_id
previous_hop_ip = hop_ip
# Save hop details
cursor.execute("INSERT INTO HopDetails (hop_name, hop_ip, hop_latency) VALUES (?, ?, ?)",
(hop_name, hop_ip, hop_latency))
# calculate link latency if possible and store it
if link_id and previous_hop_latency:
link_latency = hop_latency - previous_hop_latency
cursor.execute("INSERT INTO Latency (link_id, timestamp, latency_ms) VALUES (?, ?, ?)",
(link_id, trace['timestamp'], link_latency))
# make entry to "Paths" table
if path_ids:
json_path_ids = json.dumps(path_ids)
cursor.execute("INSERT OR IGNORE INTO Paths (node, target, hops_json) VALUES (?, ?, ?)",
(node, trace['target'], json_path_ids))
conn.commit() conn.commit()
conn.close() conn.close()
def retrieve_traceroute(): def retrieve_traceroute(db_file):
conn = sqlite3.connect('traceroute.db')
retval = {}
conn = sqlite3.connect(db_file)
cursor = conn.cursor() cursor = conn.cursor()
cursor.execute(''' cursor.execute('''
SELECT l.source_ip, l.destination_ip, ll.latency, ll.timestamp SELECT target, hops_json
FROM link_latency ll FROM Paths
JOIN links l ON ll.link_id = l.id
ORDER BY ll.timestamp
''') ''')
rows = cursor.fetchall() retval['path'] = cursor.fetchall()
cursor.execute('''
SELECT source_ip, destination_ip
FROM Links
''')
retval['links'] = cursor.fetchall()
conn.close() conn.close()
return rows return retval
def generate_node_id():
mac = uuid.getnode()
mac_str = ':'.join(['{:02x}'.format((mac >> ele) & 0xff) for ele in range(0,8*6,8)][::-1])
# Hash the MAC address using SHA-256 to generate a unique ID
unique_id = hashlib.sha256(mac_str.encode()).hexdigest()
return unique_id
if __name__ == '__main__': if __name__ == '__main__':
databasefile="./traceroute.db" db_file="./traceroute.db"
create_tables(databasefile) create_tables(db_file)
my_id = generate_node_id()
target='1.1.1.1'
target='vi.fi'
traceroute_output, timestamp = run_traceroute(target) traceroute_output, timestamp = run_traceroute(target)
hops = parse_traceroute_output(traceroute_output, timestamp) trace = parse_traceroute_output(traceroute_output, timestamp)
store_traceroute(db_file, my_id, trace)
print("#####") print("#####")
print(hops) print(retrieve_traceroute(db_file))
print("#####") print("#####")
exit(0) exit(0)