updated to show when is not online

signage_player/get_playlists.py

@@ -6,6 +6,49 @@ import re
 import datetime
 from logging_config import Logger
 
+# Global variable to track server connectivity status
+SERVER_CONNECTION_STATUS = {
+    'is_online': True,
+    'last_successful_connection': None,
+    'last_playlist_update': None,
+    'error_message': None
+}
+
+def get_server_status():
+    """Get current server connection status"""
+    return SERVER_CONNECTION_STATUS.copy()
+
+def get_last_playlist_update_time():
+    """Get the timestamp of the last playlist update from filesystem"""
+    try:
+        playlist_dir = os.path.join(os.path.dirname(__file__), 'static_data', 'playlist')
+        if os.path.exists(playlist_dir):
+            playlist_files = [f for f in os.listdir(playlist_dir) if f.startswith('server_playlist_v') and f.endswith('.json')]
+            if playlist_files:
+                # Get the most recent playlist file
+                latest_file = max([os.path.join(playlist_dir, f) for f in playlist_files], key=os.path.getmtime)
+                mod_time = os.path.getmtime(latest_file)
+                return datetime.datetime.fromtimestamp(mod_time)
+        return None
+    except Exception as e:
+        Logger.error(f"Error getting last playlist update time: {e}")
+        return None
+
+def set_server_offline(error_message=None):
+    """Mark server as offline with optional error message"""
+    global SERVER_CONNECTION_STATUS
+    SERVER_CONNECTION_STATUS['is_online'] = False
+    SERVER_CONNECTION_STATUS['error_message'] = error_message
+    Logger.warning(f"Server marked as offline: {error_message}")
+
+def set_server_online():
+    """Mark server as online and update connection time"""
+    global SERVER_CONNECTION_STATUS
+    SERVER_CONNECTION_STATUS['is_online'] = True
+    SERVER_CONNECTION_STATUS['last_successful_connection'] = datetime.datetime.now()
+    SERVER_CONNECTION_STATUS['error_message'] = None
+    Logger.info("Server connection restored")
+
 def send_player_feedback(config, message, status="active", playlist_version=None, error_details=None):
     """
     Send feedback to the server about player status.
@@ -51,16 +94,21 @@ def send_player_feedback(config, message, status="active", playlist_version=None
         
         if response.status_code == 200:
             Logger.info(f"Feedback sent successfully: {message}")
+            # Mark server as online on successful feedback
+            set_server_online()
             return True
         else:
             Logger.warning(f"Feedback failed with status {response.status_code}: {response.text}")
+            set_server_offline(f"Feedback failed with status {response.status_code}")
             return False
             
     except requests.exceptions.RequestException as e:
         Logger.error(f"Failed to send feedback: {e}")
+        set_server_offline(f"Network error during feedback: {e}")
         return False
     except Exception as e:
         Logger.error(f"Unexpected error sending feedback: {e}")
+        set_server_offline(f"Unexpected error during feedback: {e}")
         return False
 
 def send_playlist_check_feedback(config, playlist_version=None):
@@ -187,25 +235,44 @@ def fetch_server_playlist(config):
             'quickconnect_code': quick
         }
         Logger.info(f"Fetching playlist from URL: {server_url} with params: {params}")
-        response = requests.get(server_url, params=params)
+        response = requests.get(server_url, params=params, timeout=15)
+        
         if response.status_code == 200:
             response_data = response.json()
             Logger.info(f"Server response: {response_data}")
             playlist = response_data.get('playlist', [])
             version = response_data.get('playlist_version', None)
             hashed_quickconnect = response_data.get('hashed_quickconnect', None)
+            
             if version is not None and hashed_quickconnect is not None:
                 if bcrypt.checkpw(quick.encode('utf-8'), hashed_quickconnect.encode('utf-8')):
                     Logger.info("Fetched updated playlist from server.")
+                    # Mark server as online on successful connection
+                    set_server_online()
                     return {'playlist': playlist, 'version': version}
                 else:
                     Logger.error("Quickconnect code validation failed.")
+                    set_server_offline("Authentication failed - invalid quickconnect code")
             else:
                 Logger.error("Failed to retrieve playlist or hashed quickconnect from the response.")
+                set_server_offline("Invalid server response - missing playlist data")
         else:
             Logger.error(f"Failed to fetch playlist. Status Code: {response.status_code}")
+            set_server_offline(f"Server returned error code: {response.status_code}")
+            
+    except requests.exceptions.ConnectTimeout as e:
+        Logger.error(f"Connection timeout while fetching playlist: {e}")
+        set_server_offline("Connection timeout - server unreachable")
+    except requests.exceptions.ConnectionError as e:
+        Logger.error(f"Connection error while fetching playlist: {e}")
+        set_server_offline("Connection failed - server unreachable")
     except requests.exceptions.RequestException as e:
-        Logger.error(f"Failed to fetch playlist: {e}")
+        Logger.error(f"Request error while fetching playlist: {e}")
+        set_server_offline(f"Network error: {str(e)}")
+    except Exception as e:
+        Logger.error(f"Unexpected error while fetching playlist: {e}")
+        set_server_offline(f"Unexpected error: {str(e)}")
+        
     return {'playlist': [], 'version': 0}
 
 def save_playlist_with_version(playlist_data, playlist_dir):
@@ -292,6 +359,8 @@ def update_playlist_if_needed(local_playlist_path, config, media_dir, playlist_d
     Also sends feedback to server about playlist check.
     """
     import json
+    global SERVER_CONNECTION_STATUS
+    
     server_data = fetch_server_playlist(config)
     server_version = server_data.get('version', 0)
     if not os.path.exists(local_playlist_path):
@@ -303,10 +372,11 @@ def update_playlist_if_needed(local_playlist_path, config, media_dir, playlist_d
     
     Logger.info(f"Local playlist version: {local_version}, Server playlist version: {server_version}")
     
-    # Send feedback about server interrogation (checking for updates)
-    send_playlist_check_feedback(config, server_version if server_version > 0 else local_version)
+    # Only send feedback if server is online
+    if SERVER_CONNECTION_STATUS['is_online']:
+        send_playlist_check_feedback(config, server_version if server_version > 0 else local_version)
     
-    if local_version != server_version:
+    if local_version != server_version and server_version > 0:
         if server_data and server_data.get('playlist'):
             updated_playlist = download_media_files(server_data['playlist'], media_dir)
             server_data['playlist'] = updated_playlist
@@ -314,16 +384,15 @@ def update_playlist_if_needed(local_playlist_path, config, media_dir, playlist_d
             # Delete old playlists and unreferenced media
             delete_old_playlists_and_media(server_version, playlist_dir, media_dir)
             
+            # Update last playlist update time
+            SERVER_CONNECTION_STATUS['last_playlist_update'] = datetime.datetime.now()
+            
             return True
         else:
             Logger.warning("No playlist data fetched from server or playlist is empty.")
-            
-            # Send error feedback
-            send_player_error_feedback(config, "No playlist data fetched from server or playlist is empty", local_version)
-            
             return False
     else:
-        Logger.info("Local playlist is already up to date.")
+        Logger.info("Local playlist is already up to date or server is offline.")
         return False