432 lines
16 KiB
Python
432 lines
16 KiB
Python
# FlightMonitor/data/storage.py
|
|
import sqlite3
|
|
import os
|
|
from datetime import (
|
|
datetime,
|
|
timezone,
|
|
timedelta,
|
|
)
|
|
from typing import Optional, List, Dict, Any
|
|
import time
|
|
|
|
from flightmonitor.data.common_models import CanonicalFlightState
|
|
from flightmonitor.utils.logger import get_logger
|
|
from flightmonitor.data import config as app_config
|
|
|
|
module_logger = get_logger(__name__)
|
|
|
|
|
|
class DataStorage:
|
|
"""
|
|
Handles storage of flight data into daily SQLite database files.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._current_db_path: Optional[str] = None
|
|
self._connection: Optional[sqlite3.Connection] = None
|
|
self._ensure_database_directory()
|
|
module_logger.info("DataStorage initialized.")
|
|
|
|
def _ensure_database_directory(self):
|
|
try:
|
|
abs_db_dir = os.path.abspath(app_config.DATABASE_DIRECTORY)
|
|
if not os.path.exists(abs_db_dir):
|
|
os.makedirs(abs_db_dir)
|
|
module_logger.info(f"Database directory created: {abs_db_dir}")
|
|
if not os.path.isdir(abs_db_dir):
|
|
raise OSError(f"Path {abs_db_dir} exists but is not a directory.")
|
|
if not os.access(abs_db_dir, os.W_OK):
|
|
raise OSError(f"Directory {abs_db_dir} is not writable.")
|
|
except OSError as e:
|
|
module_logger.error(
|
|
f"Database directory error for {app_config.DATABASE_DIRECTORY}: {e}",
|
|
exc_info=True,
|
|
)
|
|
raise
|
|
|
|
def _get_db_path_for_date(self, target_date_utc: Optional[datetime] = None) -> str:
|
|
if target_date_utc is None:
|
|
target_date_utc = datetime.now(timezone.utc)
|
|
db_filename = target_date_utc.strftime(app_config.DATABASE_FILENAME_FORMAT)
|
|
db_path = os.path.join(
|
|
os.path.abspath(app_config.DATABASE_DIRECTORY), db_filename
|
|
)
|
|
return db_path
|
|
|
|
def _get_db_connection(
|
|
self, for_date_utc: Optional[datetime] = None
|
|
) -> Optional[sqlite3.Connection]:
|
|
target_db_path = self._get_db_path_for_date(for_date_utc)
|
|
if self._connection and self._current_db_path == target_db_path:
|
|
return self._connection
|
|
if self._connection:
|
|
try:
|
|
self._connection.close()
|
|
module_logger.info(f"Closed DB connection to: {self._current_db_path}")
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"Error closing previous DB connection to {self._current_db_path}: {e}"
|
|
)
|
|
self._connection = None
|
|
self._current_db_path = target_db_path
|
|
try:
|
|
self._connection = sqlite3.connect(target_db_path, timeout=10.0)
|
|
self._connection.execute("PRAGMA foreign_keys = ON;")
|
|
self._connection.row_factory = sqlite3.Row
|
|
module_logger.info(f"Opened DB connection to: {target_db_path}")
|
|
self._init_tables_if_not_exist(self._connection)
|
|
return self._connection
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"Failed to connect/initialize database {target_db_path}: {e}",
|
|
exc_info=True,
|
|
)
|
|
if self._connection:
|
|
try:
|
|
self._connection.close()
|
|
except sqlite3.Error:
|
|
pass
|
|
self._connection = None
|
|
self._current_db_path = None
|
|
return None
|
|
|
|
def _init_tables_if_not_exist(self, db_conn: sqlite3.Connection):
|
|
cursor = None
|
|
try:
|
|
cursor = db_conn.cursor()
|
|
cursor.execute(
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS flights (
|
|
flight_id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
icao24 TEXT NOT NULL UNIQUE,
|
|
callsign TEXT,
|
|
origin_country TEXT,
|
|
first_seen_day REAL NOT NULL,
|
|
last_seen_day REAL NOT NULL
|
|
)
|
|
"""
|
|
)
|
|
|
|
# MODIFICA: Aggiunto vincolo UNIQUE alla tabella positions
|
|
cursor.execute(
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS positions (
|
|
position_id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
flight_id INTEGER NOT NULL,
|
|
detection_timestamp REAL NOT NULL,
|
|
latitude REAL NOT NULL,
|
|
longitude REAL NOT NULL,
|
|
baro_altitude_m REAL,
|
|
geo_altitude_m REAL,
|
|
velocity_mps REAL,
|
|
true_track_deg REAL,
|
|
vertical_rate_mps REAL,
|
|
on_ground BOOLEAN NOT NULL,
|
|
squawk TEXT,
|
|
spi BOOLEAN,
|
|
position_source TEXT,
|
|
raw_data_provider TEXT,
|
|
recorded_at REAL NOT NULL,
|
|
FOREIGN KEY (flight_id) REFERENCES flights(flight_id) ON DELETE CASCADE,
|
|
UNIQUE(flight_id, detection_timestamp)
|
|
)
|
|
"""
|
|
)
|
|
cursor.execute(
|
|
"CREATE INDEX IF NOT EXISTS idx_positions_flight_id_timestamp ON positions (flight_id, detection_timestamp);"
|
|
)
|
|
cursor.execute(
|
|
"CREATE INDEX IF NOT EXISTS idx_flights_icao24 ON flights (icao24);"
|
|
)
|
|
cursor.execute(
|
|
"CREATE INDEX IF NOT EXISTS idx_positions_detection_timestamp ON positions (detection_timestamp);"
|
|
)
|
|
db_conn.commit()
|
|
module_logger.debug(
|
|
f"Database tables and indexes ensured in {self._current_db_path}."
|
|
)
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"Error initializing tables in {self._current_db_path}: {e}",
|
|
exc_info=True,
|
|
)
|
|
if db_conn:
|
|
db_conn.rollback()
|
|
finally:
|
|
if cursor:
|
|
cursor.close()
|
|
|
|
def add_or_update_flight_daily(
|
|
self,
|
|
icao24: str,
|
|
callsign: Optional[str],
|
|
origin_country: Optional[str],
|
|
detection_timestamp: float,
|
|
) -> Optional[int]:
|
|
if not icao24:
|
|
module_logger.warning("icao24 is required to add or update a flight.")
|
|
return None
|
|
|
|
event_date_utc = datetime.fromtimestamp(detection_timestamp, timezone.utc)
|
|
conn = self._get_db_connection(for_date_utc=event_date_utc)
|
|
if not conn:
|
|
module_logger.error(
|
|
"Failed to get DB connection for add_or_update_flight_daily."
|
|
)
|
|
return None
|
|
|
|
cursor = None
|
|
flight_id: Optional[int] = None
|
|
try:
|
|
cursor = conn.cursor()
|
|
cursor.execute(
|
|
"SELECT flight_id, callsign FROM flights WHERE icao24 = ?", (icao24,)
|
|
)
|
|
row = cursor.fetchone()
|
|
|
|
if row:
|
|
flight_id = row["flight_id"]
|
|
existing_callsign = row["callsign"]
|
|
final_callsign = existing_callsign
|
|
if callsign and callsign != existing_callsign:
|
|
final_callsign = callsign
|
|
elif not existing_callsign and callsign:
|
|
final_callsign = callsign
|
|
|
|
cursor.execute(
|
|
"""
|
|
UPDATE flights SET last_seen_day = ?, callsign = ?
|
|
WHERE flight_id = ?
|
|
""",
|
|
(detection_timestamp, final_callsign, flight_id),
|
|
)
|
|
module_logger.debug(
|
|
f"Updated flight icao24={icao24}, flight_id={flight_id}, last_seen_day={detection_timestamp:.0f} in {self._current_db_path}"
|
|
)
|
|
else:
|
|
cursor.execute(
|
|
"""
|
|
INSERT INTO flights (icao24, callsign, origin_country, first_seen_day, last_seen_day)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
""",
|
|
(
|
|
icao24,
|
|
callsign,
|
|
origin_country,
|
|
detection_timestamp,
|
|
detection_timestamp,
|
|
),
|
|
)
|
|
flight_id = cursor.lastrowid
|
|
module_logger.info(
|
|
f"Added new flight icao24={icao24}, flight_id={flight_id} to {self._current_db_path}"
|
|
)
|
|
conn.commit()
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"DB error in add_or_update_flight_daily for icao24={icao24}: {e}",
|
|
exc_info=True,
|
|
)
|
|
if conn:
|
|
conn.rollback()
|
|
flight_id = None
|
|
finally:
|
|
if cursor:
|
|
cursor.close()
|
|
return flight_id
|
|
|
|
def add_position_daily(
|
|
self, flight_id: int, flight_state_obj: CanonicalFlightState
|
|
) -> Optional[int]:
|
|
if not flight_id:
|
|
module_logger.warning("flight_id is required to add a position.")
|
|
return None
|
|
if not isinstance(flight_state_obj, CanonicalFlightState):
|
|
module_logger.error(
|
|
f"Invalid type for flight_state_obj: expected CanonicalFlightState, got {type(flight_state_obj)}"
|
|
)
|
|
return None
|
|
|
|
event_date_utc = datetime.fromtimestamp(
|
|
flight_state_obj.timestamp, timezone.utc
|
|
)
|
|
conn = self._get_db_connection(for_date_utc=event_date_utc)
|
|
if not conn:
|
|
module_logger.error(
|
|
f"Failed to get DB connection for add_position_daily (flight_id={flight_id})."
|
|
)
|
|
return None
|
|
|
|
cursor = None
|
|
position_id: Optional[int] = None
|
|
recorded_at_ts = time.time()
|
|
|
|
if flight_state_obj.latitude is None or flight_state_obj.longitude is None:
|
|
module_logger.warning(
|
|
f"Skipping position for flight_id={flight_id} (ICAO: {flight_state_obj.icao24}) "
|
|
f"due to missing latitude/longitude. Timestamp: {flight_state_obj.timestamp:.0f}"
|
|
)
|
|
return None
|
|
|
|
try:
|
|
cursor = conn.cursor()
|
|
|
|
# MODIFICA: Utilizza INSERT OR IGNORE per evitare duplicati
|
|
sql = """
|
|
INSERT OR IGNORE INTO positions (
|
|
flight_id, detection_timestamp, latitude, longitude,
|
|
baro_altitude_m, geo_altitude_m, velocity_mps, true_track_deg,
|
|
vertical_rate_mps, on_ground, squawk, spi, position_source,
|
|
raw_data_provider, recorded_at
|
|
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
"""
|
|
params = (
|
|
flight_id,
|
|
flight_state_obj.timestamp,
|
|
flight_state_obj.latitude,
|
|
flight_state_obj.longitude,
|
|
flight_state_obj.baro_altitude_m,
|
|
flight_state_obj.geo_altitude_m,
|
|
flight_state_obj.velocity_mps,
|
|
flight_state_obj.true_track_deg,
|
|
flight_state_obj.vertical_rate_mps,
|
|
flight_state_obj.on_ground,
|
|
flight_state_obj.squawk,
|
|
flight_state_obj.spi,
|
|
(
|
|
str(flight_state_obj.position_source)
|
|
if flight_state_obj.position_source is not None
|
|
else None
|
|
),
|
|
flight_state_obj.raw_data_provider,
|
|
recorded_at_ts,
|
|
)
|
|
|
|
cursor.execute(sql, params)
|
|
|
|
# Se la riga è stata inserita (non ignorata), changes sarà 1
|
|
if cursor.rowcount > 0:
|
|
position_id = cursor.lastrowid
|
|
module_logger.debug(
|
|
f"Added position for flight_id={flight_id} at {flight_state_obj.timestamp:.0f} (pos_id={position_id})"
|
|
)
|
|
else:
|
|
module_logger.debug(
|
|
f"Ignored duplicate position for flight_id={flight_id} at {flight_state_obj.timestamp:.0f}"
|
|
)
|
|
|
|
conn.commit()
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"DB error in add_position_daily for flight_id={flight_id} (ICAO: {flight_state_obj.icao24}): {e}",
|
|
exc_info=True,
|
|
)
|
|
if conn:
|
|
conn.rollback()
|
|
position_id = None
|
|
finally:
|
|
if cursor:
|
|
cursor.close()
|
|
return position_id
|
|
|
|
def get_flight_track_for_icao_on_date(
|
|
self,
|
|
icao24_to_find: str,
|
|
target_date_utc: Optional[datetime] = None,
|
|
since_timestamp: Optional[float] = None,
|
|
) -> List[CanonicalFlightState]:
|
|
if not icao24_to_find:
|
|
return []
|
|
|
|
if target_date_utc is None:
|
|
target_date_utc = datetime.now(timezone.utc)
|
|
|
|
conn = self._get_db_connection(for_date_utc=target_date_utc)
|
|
if not conn:
|
|
return []
|
|
|
|
track_points: List[CanonicalFlightState] = []
|
|
cursor = None
|
|
try:
|
|
cursor = conn.cursor()
|
|
cursor.execute(
|
|
"SELECT flight_id FROM flights WHERE icao24 = ?",
|
|
(icao24_to_find.lower(),),
|
|
)
|
|
flight_row = cursor.fetchone()
|
|
|
|
if not flight_row:
|
|
return []
|
|
|
|
flight_id = flight_row["flight_id"]
|
|
|
|
sql_query = "SELECT * FROM positions WHERE flight_id = ?"
|
|
params = [flight_id]
|
|
|
|
if since_timestamp is not None:
|
|
sql_query += " AND detection_timestamp >= ?"
|
|
params.append(since_timestamp)
|
|
|
|
sql_query += " ORDER BY detection_timestamp ASC"
|
|
|
|
cursor.execute(sql_query, params)
|
|
position_rows = cursor.fetchall()
|
|
|
|
if not position_rows:
|
|
return []
|
|
|
|
for pos_row in position_rows:
|
|
try:
|
|
state = CanonicalFlightState(
|
|
icao24=icao24_to_find,
|
|
timestamp=pos_row["detection_timestamp"],
|
|
last_contact_timestamp=pos_row["detection_timestamp"],
|
|
latitude=pos_row["latitude"],
|
|
longitude=pos_row["longitude"],
|
|
on_ground=bool(pos_row["on_ground"]),
|
|
callsign=None,
|
|
origin_country=None,
|
|
baro_altitude_m=pos_row["baro_altitude_m"],
|
|
geo_altitude_m=pos_row["geo_altitude_m"],
|
|
velocity_mps=pos_row["velocity_mps"],
|
|
true_track_deg=pos_row["true_track_deg"],
|
|
vertical_rate_mps=pos_row["vertical_rate_mps"],
|
|
squawk=pos_row["squawk"],
|
|
spi=(
|
|
bool(pos_row["spi"]) if pos_row["spi"] is not None else None
|
|
),
|
|
position_source=pos_row["position_source"],
|
|
raw_data_provider=pos_row["raw_data_provider"],
|
|
)
|
|
track_points.append(state)
|
|
except Exception as e_state_create:
|
|
module_logger.error(
|
|
f"Error creating CanonicalFlightState from DB row for ICAO {icao24_to_find}: {e_state_create}",
|
|
exc_info=True,
|
|
)
|
|
continue
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"DB error retrieving track for {icao24_to_find} on {target_date_utc.strftime('%Y-%m-%d')}: {e}",
|
|
exc_info=True,
|
|
)
|
|
finally:
|
|
if cursor:
|
|
cursor.close()
|
|
return track_points
|
|
|
|
def close_connection(self):
|
|
if self._connection:
|
|
try:
|
|
self._connection.close()
|
|
module_logger.info(
|
|
f"DB connection to {self._current_db_path} closed by request."
|
|
)
|
|
except sqlite3.Error as e:
|
|
module_logger.error(
|
|
f"Error explicitly closing DB connection to {self._current_db_path}: {e}"
|
|
)
|
|
finally:
|
|
self._connection = None
|
|
self._current_db_path = None
|