182 lines
6.7 KiB
Python
182 lines
6.7 KiB
Python
from core.observers.Notifications import Notifications, EventType
|
|
from core.models.system.SystemState import SystemState
|
|
from core.models.session.SessionState import SessionState
|
|
from core.models.enum_models import ProtocolChoice
|
|
from core.errors.logger import logger
|
|
|
|
from dataclasses import dataclass, field
|
|
from typing import Optional, Dict
|
|
import subprocess
|
|
from enum import Enum
|
|
|
|
class ProcessType(Enum):
|
|
NETWORK = "network"
|
|
APP = "app"
|
|
DISPLAY = "display"
|
|
ACTIVE = "active"
|
|
|
|
|
|
LIST_OF_PROCESSES = [ProcessType.APP, ProcessType.DISPLAY, ProcessType.NETWORK]
|
|
|
|
@dataclass
|
|
class GlobalState:
|
|
synced: bool = False
|
|
|
|
# systemwide:
|
|
systemwide_active: bool = False
|
|
protocol: ProtocolChoice = None
|
|
firewalled: bool = False
|
|
dns_set: bool = False
|
|
systemwide_profile_id: Optional[int] = None
|
|
verified_working: bool = False
|
|
changed_port: bool = False
|
|
|
|
# session:
|
|
# session_profile_ids: list[int] = field(default_factory=list)
|
|
session_profiles: Dict[str, Dict[ProcessType, subprocess.Popen]] = field(default_factory=dict)
|
|
|
|
|
|
class ProfileStateRepository:
|
|
_instance = None
|
|
|
|
def __new__(cls):
|
|
if cls._instance is None:
|
|
cls._instance = super(ProfileStateRepository, cls).__new__(cls)
|
|
cls._instance._initialize()
|
|
return cls._instance
|
|
|
|
def _initialize(self):
|
|
self.global_state = GlobalState()
|
|
# Initial load: Sync memory with whatever is currently on disk
|
|
sys = SystemState.get()
|
|
if sys:
|
|
self.global_state.systemwide_profile_id = sys.profile_id
|
|
self.global_state.firewalled = sys.firewalled
|
|
self.global_state.dns_set = sys.dns_set
|
|
|
|
# Load existing session IDs from disk into the list
|
|
self.global_state.session_profile_ids = [s.id for s in SessionState.all()]
|
|
|
|
|
|
def sync_done(self):
|
|
"""Turn Sync on"""
|
|
self.global_state.synced = True
|
|
|
|
@property
|
|
def current_session_ids(self) -> list[int]:
|
|
"""Returns current session profile ids."""
|
|
return list(self.global_state.session_profiles.keys())
|
|
|
|
@property
|
|
def active_session_ids(self) -> list[int]:
|
|
"""Returns active session profile ids."""
|
|
current_list = self.current_session_ids
|
|
active_list = []
|
|
|
|
for each_profile_id in current_list:
|
|
try:
|
|
if self.global_state.session_profiles[each_profile_id][ProcessType.ACTIVE] is True:
|
|
active_list.append(each_profile_id)
|
|
except KeyError:
|
|
# print(f"active doesn't exist yet for profile id {each_profile_id}.")
|
|
continue
|
|
|
|
return active_list
|
|
|
|
def turn_off_system_connection(self):
|
|
"""Clear the system-wide memory cache."""
|
|
self.global_state.systemwide_profile_id = None
|
|
self.global_state.protocol = None
|
|
self.global_state.firewalled = False
|
|
self.global_state.dns_set = False
|
|
self.global_state.systemwide_active = False
|
|
self.global_state.verified_working = False
|
|
|
|
|
|
def sync_system_state(self, state: SystemState):
|
|
"""Called by SystemStateController to update memory cache."""
|
|
self.global_state.systemwide_profile_id = state.profile_id
|
|
self.global_state.protocol = state.protocol
|
|
self.global_state.firewalled = state.firewalled
|
|
self.global_state.dns_set = state.dns_set
|
|
if state.profile_id:
|
|
self.global_state.systemwide_active = True
|
|
|
|
|
|
def verify_its_up(self, profile_id: int):
|
|
"""Flips on Verification for Systemwide, if the rest of the state matches"""
|
|
self.global_state.systemwide_active = True
|
|
self.global_state.verified_working = True
|
|
|
|
def is_profile_active(self, profile_id: int) -> bool:
|
|
# Check system profile
|
|
if self.global_state.systemwide_active and self.global_state.systemwide_profile_id == profile_id:
|
|
return True
|
|
# Check session profiles
|
|
return profile_id in self.active_session_ids
|
|
|
|
|
|
def setup_session_profile(self, profile_id: int) -> None:
|
|
"""Ensures a session profile exists in the registry without overwriting existing processes."""
|
|
self.global_state.session_profiles.setdefault(profile_id, {}).setdefault(ProcessType.ACTIVE, False)
|
|
|
|
|
|
def add_session_process(self, profile_id: int, process_type: ProcessType, process: subprocess.Popen|bool) -> None:
|
|
"""Adds a live process to a specific profile id group."""
|
|
self.setup_session_profile(profile_id)
|
|
self.global_state.session_profiles[profile_id][process_type] = process
|
|
|
|
def get_entire_session_process_group(self, profile_id: int) -> Optional[Dict[ProcessType, subprocess.Popen]]:
|
|
"""Returns the entire dictionary of processes for a group, or None if not found."""
|
|
return self.global_state.session_profiles.get(profile_id)
|
|
|
|
|
|
def flip_session_profile_on(self, profile_id: int) -> bool:
|
|
"""If it has all the pre-reqs, then it sets the status to on."""
|
|
|
|
for each_type in LIST_OF_PROCESSES:
|
|
try:
|
|
if self.global_state.session_profiles[profile_id][each_type] is None:
|
|
print(f"Process is none for {each_type}")
|
|
return False
|
|
except KeyError:
|
|
logger.error(f"Missing the key {each_type}")
|
|
return False
|
|
|
|
|
|
print("Global state is setting the session profile to activated")
|
|
self.global_state.session_profiles[profile_id][ProcessType.ACTIVE] = True
|
|
return True
|
|
|
|
|
|
def get_session_process(self, profile_id: int, process_type: ProcessType) -> Optional[subprocess.Popen]:
|
|
"""Gets a single process from the session profile's group."""
|
|
# 1. Leverage the group getter
|
|
group = self.get_entire_session_process_group(profile_id)
|
|
|
|
# 2. If the group exists, try to get the specific process
|
|
if group:
|
|
return group.get(process_type)
|
|
|
|
return None
|
|
|
|
|
|
def remove_session_profile(self, profile_id: int) -> None:
|
|
""" Completely remove a profile, and it's group of processes from the registry"""
|
|
if profile_id in self.global_state.session_profiles:
|
|
del self.global_state.session_profiles[profile_id]
|
|
Notifications.emit(EventType.SESSION_PROFILE_DISABLE, profile_id)
|
|
|
|
|
|
|
|
|
|
# def sync_session_added(self, profile_id: int):
|
|
# """Called by SessionStateController to update memory cache."""
|
|
# if profile_id not in self.global_state.session_profile_ids:
|
|
# self.global_state.session_profile_ids.append(profile_id)
|
|
|
|
# def sync_session_removed(self, profile_id: int):
|
|
# """Called by SessionStateController to update memory cache."""
|
|
# if profile_id in self.global_state.session_profile_ids:
|
|
# self.global_state.session_profile_ids.remove(profile_id)
|
|
|