Add retry logic and DNS error handling for YouTube searches

src/mcp_servers/music_server.py

@@ -4,6 +4,8 @@ import requests
 import yt_dlp
 import os
 import random
+import socket
+import time as time_module
 from typing import List, Dict, Any, Optional
 from dataclasses import dataclass
 
@@ -33,6 +35,14 @@ class MusicMCPServer:
         self._recently_played = []  # List of video IDs
         self._max_recent = 20  # Remember last 20 tracks
     
+    def _check_youtube_available(self) -> bool:
+        """Check if YouTube is accessible via DNS"""
+        try:
+            socket.gethostbyname('www.youtube.com')
+            return True
+        except socket.gaierror:
+            return False
+    
     def _rate_limit_youtube(self):
         """Enforce rate limiting for YouTube API calls"""
         import time as time_module
@@ -125,7 +135,7 @@ class MusicMCPServer:
         
     def search_youtube_music(self, query: str, limit: int = 5, fast: bool = False, check_embed: bool = False) -> List[Dict[str, Any]]:
         """
-        Search for free music on YouTube
+        Search for free music on YouTube with retry logic for network issues
         
         Args:
             query: Search query (e.g., "pop music", "jazz instrumental", "song name")
@@ -139,89 +149,130 @@ class MusicMCPServer:
         # Apply rate limiting
         self._rate_limit_youtube()
         
+        # Check if YouTube is accessible before attempting search
+        if not self._check_youtube_available():
+            print("⚠️ YouTube is not accessible (DNS/network issue). Skipping YouTube search.")
+            return []
+        
         tracks = []
-        try:
-            # Use extract_flat for faster search (no full video info)
-            ydl_opts = {
-                'quiet': True,
-                'no_warnings': True,
-                'extract_flat': True,  # Fast: only get basic info
-                'default_search': 'ytsearch',
-            }
-            
-            # Search for more results to allow for filtering and random selection
-            # Increase limit to account for filtering out recently played
-            search_limit = max(limit * 3, 15)
-            
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                # Don't add "music" if query already contains it or is specific
-                if "music" not in query.lower() and len(query.split()) < 4:
-                    search_query = f"ytsearch{search_limit}:{query} music"
-                else:
-                    search_query = f"ytsearch{search_limit}:{query}"
-                
-                print(f"🔍 YouTube search query: '{search_query}'")
-                results = ydl.extract_info(search_query, download=False)
+        max_retries = 3
+        retry_delay = 2  # Start with 2 seconds
+        
+        for attempt in range(max_retries):
+            try:
+                # Try to resolve DNS first (helps diagnose network issues)
+                try:
+                    socket.gethostbyname('www.youtube.com')
+                except socket.gaierror as dns_error:
+                    if attempt < max_retries - 1:
+                        print(f"⚠️ DNS resolution failed (attempt {attempt + 1}/{max_retries}), retrying in {retry_delay}s...")
+                        time_module.sleep(retry_delay)
+                        retry_delay *= 2  # Exponential backoff
+                        continue
+                    else:
+                        print(f"❌ DNS resolution failed after {max_retries} attempts. YouTube may be blocked or network unavailable.")
+                        return tracks  # Return empty list, will fallback to SoundCloud
                 
-                # Handle different result formats from yt-dlp
-                entries = None
+                # Use extract_flat for faster search (no full video info)
+                ydl_opts = {
+                    'quiet': True,
+                    'no_warnings': True,
+                    'extract_flat': True,  # Fast: only get basic info
+                    'default_search': 'ytsearch',
+                    'socket_timeout': 30,  # Increase timeout for network issues
+                }
                 
-                if isinstance(results, dict):
-                    if 'entries' in results:
-                        entries = results['entries']
-                    elif 'id' in results:
-                        entries = [results]
-                elif isinstance(results, list):
-                    entries = results
+                # Search for more results to allow for filtering and random selection
+                # Increase limit to account for filtering out recently played
+                search_limit = max(limit * 3, 15)
                 
-                if entries:
-                    # Filter valid entries
-                    valid_entries = []
-                    for entry in entries:
-                        if entry and isinstance(entry, dict):
-                            video_id = entry.get('id') or entry.get('url', '')
-                            if video_id and video_id != 'None':
-                                valid_entries.append(entry)
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    # Don't add "music" if query already contains it or is specific
+                    if "music" not in query.lower() and len(query.split()) < 4:
+                        search_query = f"ytsearch{search_limit}:{query} music"
+                    else:
+                        search_query = f"ytsearch{search_limit}:{query}"
                     
-                    # Randomly shuffle to avoid always picking top results
-                    if len(valid_entries) > 1:
-                        random.shuffle(valid_entries)
+                    print(f"🔍 YouTube search query: '{search_query}'")
+                    results = ydl.extract_info(search_query, download=False)
                     
-                    # Filter, check embeddability, avoid recently played, and take requested limit
-                    for entry in valid_entries:
-                        if len(tracks) >= limit:
-                            break
-                            
-                        video_id = entry.get('id') or entry.get('url', '')
-                        if video_id:
-                            # Skip recently played tracks
-                            if self._is_recently_played(video_id):
-                                print(f"  ✗ Skipping recently played: {entry.get('title', 'Unknown')}")
-                                continue
-                            
-                            # Check if video is embeddable (optional)
-                            if check_embed and not self.check_video_embeddable(video_id):
-                                print(f"  ✗ Skipping non-embeddable: {entry.get('title', 'Unknown')}")
-                                continue
-                            
-                            track = {
-                                "title": entry.get('title', 'Unknown'),
-                                "artist": entry.get('uploader', entry.get('channel', 'Unknown Artist')),
-                                "url": f"https://www.youtube.com/watch?v={video_id}",
-                                "youtube_id": video_id,
-                                "duration": entry.get('duration', 0),
-                                "genre": query.split()[0] if query else "unknown",
-                                "source": "youtube"
-                            }
-                            tracks.append(track)
-                            # Mark as recently played
-                            self._add_to_recently_played(video_id)
-                            print(f"  ✓ Found: {track['title']} by {track['artist']}")
+                    # Handle different result formats from yt-dlp
+                    entries = None
+                    
+                    if isinstance(results, dict):
+                        if 'entries' in results:
+                            entries = results['entries']
+                        elif 'id' in results:
+                            entries = [results]
+                    elif isinstance(results, list):
+                        entries = results
+                    
+                    if entries:
+                        # Filter valid entries
+                        valid_entries = []
+                        for entry in entries:
+                            if entry and isinstance(entry, dict):
+                                video_id = entry.get('id') or entry.get('url', '')
+                                if video_id and video_id != 'None':
+                                    valid_entries.append(entry)
+                        
+                        # Randomly shuffle to avoid always picking top results
+                        if len(valid_entries) > 1:
+                            random.shuffle(valid_entries)
+                        
+                        # Filter, check embeddability, avoid recently played, and take requested limit
+                        for entry in valid_entries:
+                            if len(tracks) >= limit:
+                                break
+                                
+                            video_id = entry.get('id') or entry.get('url', '')
+                            if video_id:
+                                # Skip recently played tracks
+                                if self._is_recently_played(video_id):
+                                    print(f"  ✗ Skipping recently played: {entry.get('title', 'Unknown')}")
+                                    continue
+                                
+                                # Check if video is embeddable (optional)
+                                if check_embed and not self.check_video_embeddable(video_id):
+                                    print(f"  ✗ Skipping non-embeddable: {entry.get('title', 'Unknown')}")
+                                    continue
+                                
+                                track = {
+                                    "title": entry.get('title', 'Unknown'),
+                                    "artist": entry.get('uploader', entry.get('channel', 'Unknown Artist')),
+                                    "url": f"https://www.youtube.com/watch?v={video_id}",
+                                    "youtube_id": video_id,
+                                    "duration": entry.get('duration', 0),
+                                    "genre": query.split()[0] if query else "unknown",
+                                    "source": "youtube"
+                                }
+                                tracks.append(track)
+                                # Mark as recently played
+                                self._add_to_recently_played(video_id)
+                                print(f"  ✓ Found: {track['title']} by {track['artist']}")
+                        
+                        # Success! Break out of retry loop
+                        break
                             
-        except Exception as e:
-            print(f"❌ Error searching YouTube: {e}")
-            import traceback
-            traceback.print_exc()
+            except (yt_dlp.utils.DownloadError, Exception) as e:
+                error_str = str(e)
+                # Check for DNS/network errors
+                if any(keyword in error_str for keyword in ["Failed to resolve", "No address associated", "NameResolutionError", "gaierror"]):
+                    if attempt < max_retries - 1:
+                        print(f"⚠️ Network/DNS error (attempt {attempt + 1}/{max_retries}): {error_str[:100]}...")
+                        print(f"   Retrying in {retry_delay}s...")
+                        time_module.sleep(retry_delay)
+                        retry_delay *= 2  # Exponential backoff
+                        continue
+                    else:
+                        print(f"❌ Network error after {max_retries} attempts. YouTube unavailable.")
+                        return tracks
+                else:
+                    # Other errors, don't retry
+                    print(f"❌ Error searching YouTube: {e}")
+                    import traceback
+                    traceback.print_exc()
+                    break
         
         return tracks
     

src/mcp_servers/podcast_server.py

@@ -1,6 +1,8 @@
 """MCP Server for Podcast Recommendations - YouTube Integration"""
 from typing import List, Dict, Any
 import random
+import socket
+import time as time_module
 
 # Try to import yt-dlp
 try:
@@ -25,6 +27,14 @@ class PodcastMCPServer:
         self._recently_played = []
         self._max_recent = 10
     
+    def _check_youtube_available(self) -> bool:
+        """Check if YouTube is accessible via DNS"""
+        try:
+            socket.gethostbyname('www.youtube.com')
+            return True
+        except socket.gaierror:
+            return False
+    
     def _rate_limit_youtube(self):
         """Enforce rate limiting for YouTube API calls"""
         import time as time_module
@@ -88,7 +98,7 @@ class PodcastMCPServer:
     
     def search_youtube_podcast(self, query: str, category: str = "technology", limit: int = 5) -> List[Dict[str, Any]]:
         """
-        Search YouTube for podcasts
+        Search YouTube for podcasts with retry logic for network issues
         
         Args:
             query: Search query
@@ -102,78 +112,120 @@ class PodcastMCPServer:
             print("⚠️ yt-dlp not available, using demo podcasts")
             return self._get_demo_podcasts(category, limit)
         
+        # Check if YouTube is accessible before attempting search
+        if not self._check_youtube_available():
+            print("⚠️ YouTube is not accessible (DNS/network issue). Using demo podcasts.")
+            return self._get_demo_podcasts(category, limit)
+        
         # Apply rate limiting
         self._rate_limit_youtube()
         
-        try:
-            # Build search query for podcasts
-            search_query = f"{query} podcast {category}"
-            print(f"🎙️ Searching YouTube for podcast: {search_query}")
-            
-            ydl_opts = {
-                'quiet': True,
-                'no_warnings': True,
-                'extract_flat': True,
-                'default_search': 'ytsearch10',
-            }
-            
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                result = ydl.extract_info(f"ytsearch10:{search_query}", download=False)
-                
-                if not result:
-                    print("❌ No podcast results found")
-                    return self._get_demo_podcasts(category, limit)
+        max_retries = 3
+        retry_delay = 2  # Start with 2 seconds
+        
+        for attempt in range(max_retries):
+            try:
+                # Try to resolve DNS first (helps diagnose network issues)
+                try:
+                    socket.gethostbyname('www.youtube.com')
+                except socket.gaierror as dns_error:
+                    if attempt < max_retries - 1:
+                        print(f"⚠️ DNS resolution failed (attempt {attempt + 1}/{max_retries}), retrying in {retry_delay}s...")
+                        time_module.sleep(retry_delay)
+                        retry_delay *= 2  # Exponential backoff
+                        continue
+                    else:
+                        print(f"❌ DNS resolution failed after {max_retries} attempts. Using demo podcasts.")
+                        return self._get_demo_podcasts(category, limit)
                 
-                entries = result.get('entries', [])
-                if not entries:
-                    print("❌ No podcast entries found")
-                    return self._get_demo_podcasts(category, limit)
+                # Build search query for podcasts
+                search_query = f"{query} podcast {category}"
+                print(f"🎙️ Searching YouTube for podcast: {search_query}")
                 
-                # Filter and format results, checking embeddability
-                podcasts = []
-                random.shuffle(entries)  # Shuffle first for variety
+                ydl_opts = {
+                    'quiet': True,
+                    'no_warnings': True,
+                    'extract_flat': True,
+                    'default_search': 'ytsearch10',
+                    'socket_timeout': 30,  # Increase timeout for network issues
+                }
                 
-                for entry in entries:
-                    if entry is None:
-                        continue
+                with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                    result = ydl.extract_info(f"ytsearch10:{search_query}", download=False)
+                    
+                    if not result:
+                        print("❌ No podcast results found")
+                        return self._get_demo_podcasts(category, limit)
                     
-                    if len(podcasts) >= limit:
-                        break
+                    entries = result.get('entries', [])
+                    if not entries:
+                        print("❌ No podcast entries found")
+                        return self._get_demo_podcasts(category, limit)
                     
-                    video_id = entry.get('id', '')
-                    title = entry.get('title', 'Unknown Podcast')
-                    channel = entry.get('uploader', entry.get('channel', 'Unknown Host'))
-                    duration = entry.get('duration', 0)
+                    # Filter and format results, checking embeddability
+                    podcasts = []
+                    random.shuffle(entries)  # Shuffle first for variety
                     
-                    if video_id:
-                        # Check if video is embeddable
-                        if not self.check_video_embeddable(video_id):
-                            print(f"  ✗ Skipping non-embeddable podcast: {title[:50]}")
+                    for entry in entries:
+                        if entry is None:
                             continue
                         
-                        podcasts.append({
-                            "title": title,
-                            "description": f"Podcast episode about {category}",
-                            "host": channel,
-                            "duration": f"{duration // 60} min" if duration else "Unknown",
-                            "duration_seconds": duration or 0,
-                            "category": category,
-                            "rating": round(random.uniform(4.0, 5.0), 1),
-                            "source": "youtube",
-                            "youtube_id": video_id,
-                            "url": f"https://www.youtube.com/watch?v={video_id}"
-                        })
-                        print(f"  ✓ Found embeddable podcast: {title[:50]}")
+                        if len(podcasts) >= limit:
+                            break
+                        
+                        video_id = entry.get('id', '')
+                        title = entry.get('title', 'Unknown Podcast')
+                        channel = entry.get('uploader', entry.get('channel', 'Unknown Host'))
+                        duration = entry.get('duration', 0)
+                        
+                        if video_id:
+                            # Check if video is embeddable
+                            if not self.check_video_embeddable(video_id):
+                                print(f"  ✗ Skipping non-embeddable podcast: {title[:50]}")
+                                continue
+                            
+                            podcasts.append({
+                                "title": title,
+                                "description": f"Podcast episode about {category}",
+                                "host": channel,
+                                "duration": f"{duration // 60} min" if duration else "Unknown",
+                                "duration_seconds": duration or 0,
+                                "category": category,
+                                "rating": round(random.uniform(4.0, 5.0), 1),
+                                "source": "youtube",
+                                "youtube_id": video_id,
+                                "url": f"https://www.youtube.com/watch?v={video_id}"
+                            })
+                            print(f"  ✓ Found embeddable podcast: {title[:50]}")
+                    
+                    if podcasts:
+                        print(f"✅ Found {len(podcasts)} embeddable podcasts on YouTube")
+                        return podcasts
+                    else:
+                        return self._get_demo_podcasts(category, limit)
                 
-                if podcasts:
-                    print(f"✅ Found {len(podcasts)} embeddable podcasts on YouTube")
-                    return podcasts
+                # Success! Break out of retry loop
+                break
+                    
+            except (yt_dlp.utils.DownloadError, Exception) as e:
+                error_str = str(e)
+                # Check for DNS/network errors
+                if any(keyword in error_str for keyword in ["Failed to resolve", "No address associated", "NameResolutionError", "gaierror"]):
+                    if attempt < max_retries - 1:
+                        print(f"⚠️ Network/DNS error (attempt {attempt + 1}/{max_retries}): {error_str[:100]}...")
+                        print(f"   Retrying in {retry_delay}s...")
+                        time_module.sleep(retry_delay)
+                        retry_delay *= 2  # Exponential backoff
+                        continue
+                    else:
+                        print(f"❌ Network error after {max_retries} attempts. Using demo podcasts.")
+                        return self._get_demo_podcasts(category, limit)
                 else:
+                    # Other errors, don't retry
+                    print(f"❌ Error searching YouTube for podcasts: {e}")
                     return self._get_demo_podcasts(category, limit)
-                    
-        except Exception as e:
-            print(f"❌ Error searching YouTube for podcasts: {e}")
-            return self._get_demo_podcasts(category, limit)
+        
+        return self._get_demo_podcasts(category, limit)
     
     def _get_demo_podcasts(self, category: str, limit: int) -> List[Dict[str, Any]]:
         """Get demo podcasts as fallback"""