From 53dc71bf01fd355ec6898d5f66f32035587d788a Mon Sep 17 00:00:00 2001 From: SimplifiedPrivacy Date: Mon, 16 Nov 2026 19:32:07 -0500 Subject: [PATCH] Catching detached session in the wrapper. And application version download failures --- .../ApplicationVersionController.py | 56 ++++++++++++------- core/infrastructure/plumbing.py | 2 - core/models/DatabaseOperation.py | 1 + core/models/manage/lifecycle_tools.py | 9 +++ core/models/manage/session_management.py | 23 +++----- core/models/manage/wrapper.py | 45 ++++++++++++--- core/services/profiles/profile_connections.py | 4 +- 7 files changed, 93 insertions(+), 47 deletions(-) create mode 100644 core/models/manage/lifecycle_tools.py diff --git a/core/controllers/ApplicationVersionController.py b/core/controllers/ApplicationVersionController.py index 565a6ac..0dcc9e5 100644 --- a/core/controllers/ApplicationVersionController.py +++ b/core/controllers/ApplicationVersionController.py @@ -19,6 +19,7 @@ from core.models.orm_calls.application_version_calls import get_application_vers from core.observers.ApplicationVersionObserver import ApplicationVersionObserver from core.observers.ConnectionObserver import ConnectionObserver from core.services.WebServiceApiService import WebServiceApiService +from core.models.Result import Result, ResultError from core.errors.logger import logger # import httpx @@ -48,7 +49,12 @@ class ApplicationVersionController: @staticmethod - def install(application_version: ApplicationVersion, reinstall: bool = False, application_version_observer: Optional[ApplicationVersionObserver] = None, connection_observer: Optional[ConnectionObserver] = None): + def install( + application_version: ApplicationVersion, + reinstall: bool = False, + application_version_observer: Optional[ApplicationVersionObserver] = None, + connection_observer: Optional[ConnectionObserver] = None + ) -> Result: if not application_version.is_supported: raise UnsupportedApplicationVersionError('The application version in question is not supported.') @@ -57,10 +63,12 @@ class ApplicationVersionController: ApplicationVersionController.uninstall(application_version) if application_version.is_installed(): - raise ApplicationAlreadyInstalledError('The application in question is already installed.') + error_msg = 'The application in question is already installed.' + logger.error(error_msg) + return Result(valid=False, error_type=ResultError.INVALID_INPUT, message=error_msg) # this used to go through "with_preferred_connection", but now re-uses the same HTTPx client as sync, - ApplicationVersionController.__install(application_version, application_version_observer, connection_observer) + return ApplicationVersionController.__install(application_version, application_version_observer, connection_observer) # legacy: # from core.controllers.ConnectionController import ConnectionController @@ -87,7 +95,12 @@ class ApplicationVersionController: ApplicationVersion.save_many(application_versions) @staticmethod - def __install(application_version: ApplicationVersion, application_version_observer: Optional[ApplicationVersionObserver] = None, connection_observer: Optional[ConnectionObserver] = None): + def __install( + application_version: ApplicationVersion, + application_version_observer: Optional[ApplicationVersionObserver] = None, + connection_observer: Optional[ConnectionObserver] = None + ) -> Result: + target_app_name = application_version.application_code.capitalize() target_app_version = application_version.version_number download_path = application_version.download_path @@ -105,29 +118,30 @@ class ApplicationVersionController: connection_observer=connection_observer ) - ################################################ - # IT WORKED - SAVE IT - ################################################ - if download_result.valid: - response_buffer = download_result.data - file_hash = download_result.message + if not download_result.valid: + return download_result.wrap("failed to download") - with tarfile.open(fileobj=response_buffer, mode = 'r:gz') as tar_file: - tar_file.extractall(application_version.get_installation_path()) + response_buffer = download_result.data + file_hash = download_result.message - with open(f'{application_version.get_installation_path()}/.sha3-512', 'w') as hash_file: - hash_file.write(f'{file_hash}\n') + with tarfile.open(fileobj=response_buffer, mode = 'r:gz') as tar_file: + tar_file.extractall(application_version.get_installation_path()) + + with open(f'{application_version.get_installation_path()}/.sha3-512', 'w') as hash_file: + hash_file.write(f'{file_hash}\n') + + return Result(valid=True) ################################################ # FAILED ################################################ - else: - if download_result.error_type == ResultError.CONNECTION: - raise ConnectionError(f'Could not connect, to download {target_app_name}.') - elif download_result.error_type == ResultError.INVALID_INPUT: - raise FileIntegrityError('Application version file integrity could not be verified.') - else: - return None + # else: + # if download_result.error_type == ResultError.CONNECTION: + # # raise ConnectionError(f'Could not connect, to download {target_app_name}.') + # elif download_result.error_type == ResultError.INVALID_INPUT: + # raise FileIntegrityError('Application version file integrity could not be verified.') + # else: + # return None # legacy: diff --git a/core/infrastructure/plumbing.py b/core/infrastructure/plumbing.py index 529551c..e4566e9 100644 --- a/core/infrastructure/plumbing.py +++ b/core/infrastructure/plumbing.py @@ -66,8 +66,6 @@ class ThreadPlumbing: def _on_complete(self, original_result: Result): """Get a potential function prescription and return it to the main thread.""" - logger.info(original_result) - if not original_result: return diff --git a/core/models/DatabaseOperation.py b/core/models/DatabaseOperation.py index e2876da..f90f60c 100644 --- a/core/models/DatabaseOperation.py +++ b/core/models/DatabaseOperation.py @@ -22,6 +22,7 @@ class DBErrorType(Enum): CORRUPTED_DATABASE = "corrupted_database" PYTHON_MODEL_STRUCTURE = "python_model_structure" SQLALCHEMY_ERROR = "sqlalchemy_error" + DETACHED = "detached" UNKNOWN_MODEL = "unknown_model" UNKNOWN = "unknown" diff --git a/core/models/manage/lifecycle_tools.py b/core/models/manage/lifecycle_tools.py new file mode 100644 index 0000000..34e6b56 --- /dev/null +++ b/core/models/manage/lifecycle_tools.py @@ -0,0 +1,9 @@ + + +from sqlalchemy import inspect + +def is_model_stale(obj): + """"checks the internal state of an object, to evaluate if its detatched or expired."""" + ins = inspect(obj) + return ins.detached or ins.expired + diff --git a/core/models/manage/session_management.py b/core/models/manage/session_management.py index c54b647..f941cdb 100644 --- a/core/models/manage/session_management.py +++ b/core/models/manage/session_management.py @@ -58,6 +58,8 @@ def _reinitialize_engine_and_session(): engine = create_engine(f"sqlite:///{database_path}") Session = sessionmaker(bind=engine) + # uncomment if going to be destroying SQL threads without clearing cache or DTO: + # Session = sessionmaker(bind=engine, expire_on_commit=False) @@ -83,6 +85,12 @@ def close_session(): _session.close() _session = None +def create_new_session(): + """Create and return a brand new session instance from the global factory.""" + if Session is None: + raise RuntimeError("Session factory not initialized. Call _reinitialize_engine_and_session() first.") + return Session() + # ============================================================================ # DATABASE OPERATIONS @@ -113,21 +121,6 @@ def create_ONLY_db_version_table(): logger.error(f"[DB MANAGEMENT] Failed to create/initialize database_version table: {e}") -# def create_ONLY_db_version_table(): -# """Create only the database_version table using the global engine.""" -# if engine is None: -# raise RuntimeError("Engine not initialized. Call _reinitialize_engine_and_session() first.") - -# from core.models.orm_models.DatabaseVersion import database_version -# try: -# database_version.create(engine) -# except: -# logger.info("[DB MANAGEMENT] database_version already exists, but was attempted to be made again by calling create_ONLY_db_version_table.") - -# # if using without checking or try except blocks: -# # database_version.create(engine, checkfirst=True) - - def does_db_version_table_exist(): if engine is None: raise RuntimeError("Engine not initialized. Call _reinitialize_engine_and_session() first.") diff --git a/core/models/manage/wrapper.py b/core/models/manage/wrapper.py index 4d0c3f4..424e202 100644 --- a/core/models/manage/wrapper.py +++ b/core/models/manage/wrapper.py @@ -1,20 +1,21 @@ # custom -from core.errors.logger import logger from core.models.DatabaseOperation import DatabaseOperation, DBErrorType from core.models.manage.migrations import migrate_sql -from core.models.manage.session_management import get_session -from core.Constants import Constants +from core.models.manage.session_management import get_session, create_new_session +# from core.Constants import Constants +from core.errors.logger import logger # generic -from sqlalchemy.orm import Session +# from sqlalchemy.orm import Session from sqlalchemy.exc import ( OperationalError, IntegrityError, SQLAlchemyError ) -from typing import Type, Dict, Any, Callable, TypeVar -from functools import wraps -from enum import Enum +from sqlalchemy.orm.exc import DetachedInstanceError +# from typing import Type, Dict, Any, Callable, TypeVar +# from functools import wraps +# from enum import Enum import traceback @@ -46,7 +47,35 @@ def safe_db_operation(func): # Otherwise, wrap success return DatabaseOperation(valid=True, data=result) - + + except DetachedInstanceError as e: + logger.warning(f"DetachedInstanceError: {e}. Retrying with a brand new session.") + + # Create a new session on this thread: + temp_session = create_new_session() + try: + # Retry the call with the fresh session + result = func(*args, session=temp_session, **kwargs) + error_msg = "Recovered DetachedInstanceError with new session" + logger.info(error_msg) + return DatabaseOperation( + valid=True, + data=result, + message=error_msg + ) + except Exception as retry_error: + logger.error(f"DetachedInstanceError recovery failed with error: {str(retry_error)}", exc_info=True) + session.rollback() + return DatabaseOperation( + valid=False, + error_type=DBErrorType.DETACHED, + message=str(retry_error) + ) + finally: + # Close the new session to prevent "Too many connections" errors + temp_session.close() + + except OperationalError as e: logger.error(f"Schema mismatch in {func.__name__}: {e}") session.rollback() diff --git a/core/services/profiles/profile_connections.py b/core/services/profiles/profile_connections.py index 3278ecc..abd904b 100644 --- a/core/services/profiles/profile_connections.py +++ b/core/services/profiles/profile_connections.py @@ -102,7 +102,9 @@ def enable_session_profile( application_version = profile.application_version if not application_version.is_installed(): - ApplicationVersionController.install(application_version, application_version_observer=application_version_observer, connection_observer=connection_observer) + install_result = ApplicationVersionController.install(application_version, application_version_observer=application_version_observer, connection_observer=connection_observer) + if not install_result.valid: + return install_result.wrap("Can't enable session profile, because it couldn't get the app") #----------------------------------- # NETWORK CONFIG