update: updated gui status handling

gui/v2/infrastructure/setup_observers.py

@@ -30,6 +30,29 @@ profile_observer = ProfileObserver()
 ticket_observer = TicketObserver()
 
 
+def observer_message(topic, event):
+    subject = getattr(event, 'subject', None)
+    meta = getattr(event, 'meta', None)
+    if subject is not None:
+        return str(subject)
+    if meta:
+        return str(meta)
+    return str(topic)
+
+
+def subscribe_observer_messages(observer, post_status):
+    for attr in dir(observer):
+        if not attr.startswith('on_'):
+            continue
+        callbacks = getattr(observer, attr, None)
+        if not isinstance(callbacks, list):
+            continue
+        topic = attr[3:]
+        observer.subscribe(
+            topic,
+            lambda event, topic=topic: post_status(observer_message(topic, event)))
+
+
 def setup_observers(update_status):
     relay = StatusRelay(update_status)
     post_status = relay.post
@@ -39,24 +62,7 @@ def setup_observers(update_status):
     profile_observer.subscribe(
         'destroyed', lambda event: post_status('Profile destroyed'))
 
-    # client_observer.subscribe(
+    subscribe_observer_messages(client_observer, post_status)
-    #     'synchronizing', lambda event: update_status('Sync in progress...'))
-
-    client_observer.subscribe(
-        'synchronizing', lambda event: post_status(f'{event.subject if event.subject else "Sync in progress..."}'))
-
-    client_observer.subscribe(
-        'synchronized', lambda event: post_status('Sync complete'))
-
-    client_observer.subscribe(
-        'updating', lambda event: post_status('Updating client...'))
-    client_observer.subscribe('update_progressing', lambda event: post_status(
-        f'Current progress: {event.meta.get('progress'):.2f}%'))
-    client_observer.subscribe('updated', lambda event: post_status(
-        'Restart client to apply update.'))
-
-    client_observer.subscribe(
-        'custom_message', lambda event: post_status(f'{event.subject if event.subject else "Error, check logs"}'))
 
     application_version_observer.subscribe('downloading', lambda event: post_status(
         f'Downloading {ApplicationController.get(event.subject.application_code).name}'))
@@ -66,24 +72,7 @@ def setup_observers(update_status):
     application_version_observer.subscribe('downloaded', lambda event: post_status(
         f'Downloaded {ApplicationController.get(event.subject.application_code).name}'))
 
-    connection_observer.subscribe('connecting', lambda event: post_status(
+    subscribe_observer_messages(connection_observer, post_status)
-        f'[{event.subject.get("attempt_count")}/{event.subject.get("maximum_number_of_attempts")}] Performing connection attempt...'))
-
-    connection_observer.subscribe('tor_bootstrapping', lambda event: post_status(
-        'Establishing Tor connection...'))
-
-    connection_observer.subscribe(
-        'tor_bootstrap_progressing', lambda event: post_status(f'{event.subject if event.subject else "Tor Bootstrapping.."}'))
-
-    # original replaced version:
-    # connection_observer.subscribe('tor_bootstrap_progressing', lambda event: update_status(
-    #     f'Bootstrapping Tor {event.meta.get('progress'):.2f}%'))
-
-    connection_observer.subscribe(
-        'tor_bootstrapped', lambda event: post_status('Tor connection established.'))
-
-    client_observer.subscribe(
-        'custom_message', lambda event: post_status(f'{event.subject if event.subject else ""}'))
 
     ticket_observer.subscribe('connecting', lambda event: post_status('Connecting to ticket server...'))
     ticket_observer.subscribe('sync_done', lambda event: post_status('Ticket prices synced.'))

gui/v2/ui/pages/editor_page.py

@@ -576,11 +576,9 @@ class EditorPage(Page):
 
     def on_sync_complete_for_edit_profile(self, available_locations, available_browsers, status, is_tor, locations, all_browsers):
         if status:
-            self.update_status.update_status('Sync complete.')
             self.extraccion()
         else:
-            self.update_status.update_status(
+            self.connection_manager.set_synced(False)
-                'Sync failed. Please try again later.')
 
     def show_previous_value(self, key: str, index: int, parameters: dict) -> None:
         if key == 'browser' or key == 'location':

gui/v2/ui/pages/menu_page.py

@@ -1031,8 +1031,6 @@ class MenuPage(Page):
             self.custom_window.navigator.navigate("fast_registration")
         else:
             self.connection_manager.set_synced(False)
-            self.update_status.update_status(
-                'Sync failed. Please try again later.')
 
     def _build_sync_worker(self):
         if self.update_status.get_current_connection() == 'tor':
@@ -1079,8 +1077,7 @@ class MenuPage(Page):
         if status:
             self.custom_window.navigator.navigate("editor")
         else:
-            self.update_status.update_status(
+            self.connection_manager.set_synced(False)
-                'Sync failed. Please try again later.')
 
     def settings_gui(self):
         self.custom_window.navigator.navigate("settings")
@@ -1175,7 +1172,7 @@ class MenuPage(Page):
             self.update_status.update_status("Syncing...")
             self.worker_thread = WorkerThread('SYNC')
             self.worker_thread.finished.connect(
-                lambda ok: self.handle_sync_after_verification(profile_id) if ok else self.update_status.update_status("Sync failed. Please try again later."))
+                lambda ok: self.handle_sync_after_verification(profile_id) if ok else None)
             self.worker_thread.sync_output.connect(
                 self.update_status.update_values)
             self.worker_thread.text_output.connect(

gui/v2/ui/pages/sync_screen.py

@@ -101,11 +101,8 @@ class SyncScreen(Page):
             self.connection_manager.set_synced(False)
             self.button_go.setEnabled(True)
             self.button_back.setEnabled(True)
-            self.update_status.update_status('An error occurred during sync')
             return
 
-        self.update_status.update_status('Sync complete')
-
         update_available = ClientController.can_be_updated()
 
         if update_available:

gui/v2/workers/worker_thread.py

@@ -224,53 +224,56 @@ class WorkerThread(QThread):
         finally:
             self.finished.emit(True)
 
+    def _emit_observer_message(self, topic, event):
+        subject = getattr(event, 'subject', None)
+        meta = getattr(event, 'meta', None)
+        if subject is not None:
+            self.text_output.emit(str(subject))
+        elif meta:
+            self.text_output.emit(str(meta))
+        else:
+            self.text_output.emit(str(topic))
+
+    def _subscribe_observer_messages(self, observer, skip_topics=None):
+        skip_topics = skip_topics or set()
+        for attr in dir(observer):
+            if not attr.startswith('on_'):
+                continue
+            callbacks = getattr(observer, attr, None)
+            if not isinstance(callbacks, list):
+                continue
+            topic = attr[3:]
+            if topic in skip_topics:
+                continue
+            observer.subscribe(
+                topic,
+                lambda event, topic=topic: self._emit_observer_message(topic, event))
+
     def sync(self):
         try:
             if self.action == 'SYNC_TOR':
                 ConfigurationController.set_connection('tor')
             else:
                 ConfigurationController.set_connection('system')
-            sync_failed = False
+            sync_succeeded = False
-
-            def sync_status(event):
-                nonlocal sync_failed
-                message = event.subject if event.subject else "Sync in progress..."
-                message_text = str(message)
-                lowered = message_text.lower()
-                if "error" in lowered or "failed" in lowered or "failure" in lowered:
-                    sync_failed = True
-                self.text_output.emit(message_text)
 
             def sync_complete(event):
-                self.text_output.emit("Sync complete")
+                nonlocal sync_succeeded
-
+                sync_succeeded = True
-            def connection_status(event):
+                self._emit_observer_message('synchronized', event)
-                subject = event.subject
-                if isinstance(subject, dict):
-                    attempt = subject.get("attempt_count")
-                    maximum = subject.get("maximum_number_of_attempts")
-                    self.text_output.emit(
-                        f"[{attempt}/{maximum}] Performing connection attempt...")
-                else:
-                    self.text_output.emit("Performing connection attempt...")
 
             sync_client_observer = ClientObserver()
             sync_connection_observer = ConnectionObserver()
-            sync_client_observer.subscribe('synchronizing', sync_status)
+            self._subscribe_observer_messages(
+                sync_client_observer, {'synchronized'})
+            self._subscribe_observer_messages(sync_connection_observer)
             sync_client_observer.subscribe('synchronized', sync_complete)
-            sync_connection_observer.subscribe('connecting', connection_status)
-            sync_connection_observer.subscribe(
-                'tor_bootstrapping', lambda event: self.text_output.emit('Establishing Tor connection...'))
-            sync_connection_observer.subscribe(
-                'tor_bootstrap_progressing', lambda event: self.text_output.emit(f'{event.subject if event.subject else "Tor Bootstrapping.."}'))
-            sync_connection_observer.subscribe(
-                'tor_bootstrapped', lambda event: self.text_output.emit('Tor connection established.'))
 
             ClientController.sync(
                 client_observer=sync_client_observer,
                 connection_observer=sync_connection_observer)
 
-            if sync_failed:
+            if not sync_succeeded:
                 self.sync_output.emit([], [], False, False, [], [])
                 self.finished.emit(False)
                 return