arch-ops-server 3.0.1__py3-none-any.whl

arch_ops_server/mirrors.py

@@ -0,0 +1,397 @@
+# SPDX-License-Identifier: GPL-3.0-only OR MIT
+"""
+Mirror management module.
+Manages and optimizes pacman mirrors for better download performance.
+"""
+
+import logging
+import re
+import time
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+
+import httpx
+
+from .utils import (
+    IS_ARCH,
+    create_error_response,
+)
+
+logger = logging.getLogger(__name__)
+
+# Mirror list path
+MIRRORLIST_PATH = "/etc/pacman.d/mirrorlist"
+
+# Arch Linux mirror status JSON
+MIRROR_STATUS_URL = "https://archlinux.org/mirrors/status/json/"
+
+
+async def list_active_mirrors() -> Dict[str, Any]:
+    """
+    List currently configured mirrors from mirrorlist.
+
+    Returns:
+        Dict with active and commented mirrors
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "This feature is only available on Arch Linux"
+        )
+
+    logger.info("Reading mirrorlist configuration")
+
+    try:
+        mirrorlist = Path(MIRRORLIST_PATH)
+
+        if not mirrorlist.exists():
+            return create_error_response(
+                "NotFound",
+                f"Mirrorlist not found at {MIRRORLIST_PATH}"
+            )
+
+        active_mirrors = []
+        commented_mirrors = []
+
+        with open(mirrorlist, 'r') as f:
+            for line in f:
+                line = line.strip()
+
+                # Skip empty lines and comments that aren't mirrors
+                if not line or (line.startswith('#') and 'Server' not in line):
+                    continue
+
+                # Check if it's a commented mirror
+                if line.startswith('#'):
+                    # Extract mirror URL
+                    match = re.search(r'Server\s*=\s*(.+)', line)
+                    if match:
+                        commented_mirrors.append({
+                            "url": match.group(1).strip(),
+                            "active": False
+                        })
+                elif line.startswith('Server'):
+                    # Active mirror
+                    match = re.search(r'Server\s*=\s*(.+)', line)
+                    if match:
+                        active_mirrors.append({
+                            "url": match.group(1).strip(),
+                            "active": True
+                        })
+
+        logger.info(f"Found {len(active_mirrors)} active, {len(commented_mirrors)} commented mirrors")
+
+        return {
+            "active_count": len(active_mirrors),
+            "commented_count": len(commented_mirrors),
+            "active_mirrors": active_mirrors,
+            "commented_mirrors": commented_mirrors,
+            "mirrorlist_path": str(mirrorlist)
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to read mirrorlist: {e}")
+        return create_error_response(
+            "MirrorlistError",
+            f"Failed to read mirrorlist: {str(e)}"
+        )
+
+
+async def test_mirror_speed(mirror_url: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Test mirror response time.
+
+    Args:
+        mirror_url: Specific mirror URL to test, or None to test all active mirrors
+
+    Returns:
+        Dict with mirror latency results
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "This feature is only available on Arch Linux"
+        )
+
+    logger.info(f"Testing mirror speed: {mirror_url or 'all active'}")
+
+    try:
+        mirrors_to_test = []
+
+        if mirror_url:
+            mirrors_to_test = [mirror_url]
+        else:
+            # Get active mirrors
+            result = await list_active_mirrors()
+            if "error" in result:
+                return result
+
+            mirrors_to_test = [m["url"] for m in result.get("active_mirrors", [])]
+
+        if not mirrors_to_test:
+            return create_error_response(
+                "NoMirrors",
+                "No mirrors to test"
+            )
+
+        results = []
+
+        async with httpx.AsyncClient(timeout=10.0, follow_redirects=True) as client:
+            for mirror in mirrors_to_test:
+                # Replace $repo and $arch with actual values for testing
+                test_url = mirror.replace("$repo", "core").replace("$arch", "x86_64")
+                
+                # Add a test file path (core.db is small and always present)
+                if not test_url.endswith('/'):
+                    test_url += '/'
+                test_url += "core.db"
+
+                try:
+                    start_time = time.time()
+                    response = await client.head(test_url)
+                    latency = (time.time() - start_time) * 1000  # Convert to ms
+
+                    results.append({
+                        "mirror": mirror,
+                        "latency_ms": round(latency, 2),
+                        "status_code": response.status_code,
+                        "success": response.status_code == 200
+                    })
+
+                except httpx.TimeoutException:
+                    results.append({
+                        "mirror": mirror,
+                        "latency_ms": -1,
+                        "status_code": 0,
+                        "success": False,
+                        "error": "timeout"
+                    })
+
+                except Exception as e:
+                    results.append({
+                        "mirror": mirror,
+                        "latency_ms": -1,
+                        "status_code": 0,
+                        "success": False,
+                        "error": str(e)
+                    })
+
+        # Sort by latency (successful tests first)
+        results.sort(key=lambda x: (not x["success"], x["latency_ms"] if x["latency_ms"] > 0 else float('inf')))
+
+        logger.info(f"Tested {len(results)} mirrors")
+
+        return {
+            "tested_count": len(results),
+            "results": results,
+            "fastest": results[0] if results and results[0]["success"] else None
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to test mirrors: {e}")
+        return create_error_response(
+            "MirrorTestError",
+            f"Failed to test mirror speed: {str(e)}"
+        )
+
+
+async def suggest_fastest_mirrors(
+    country: Optional[str] = None,
+    limit: int = 10
+) -> Dict[str, Any]:
+    """
+    Suggest optimal mirrors based on official mirror status.
+
+    Args:
+        country: Optional country code to filter mirrors (e.g., 'US', 'DE')
+        limit: Number of mirrors to suggest (default 10)
+
+    Returns:
+        Dict with recommended mirrors
+    """
+    logger.info(f"Fetching mirror suggestions (country={country}, limit={limit})")
+
+    try:
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            response = await client.get(MIRROR_STATUS_URL)
+            response.raise_for_status()
+
+            data = response.json()
+            mirrors = data.get("urls", [])
+
+            if not mirrors:
+                return create_error_response(
+                    "NoData",
+                    "No mirror data available from archlinux.org"
+                )
+
+            # Filter mirrors
+            filtered_mirrors = []
+
+            for mirror in mirrors:
+                # Skip if country specified and doesn't match
+                if country and mirror.get("country_code") != country.upper():
+                    continue
+
+                # Skip if not active or has issues
+                if not mirror.get("active", False):
+                    continue
+
+                # Skip if last sync is too old (more than 24 hours)
+                last_sync = mirror.get("last_sync")
+                if last_sync is None:
+                    continue
+
+                # Calculate score (lower is better)
+                # Factors: completion percentage, delay, duration
+                completion = mirror.get("completion_pct", 0)
+                delay = mirror.get("delay", 0) or 0  # Handle None
+                duration_avg = mirror.get("duration_avg", 0) or 0
+
+                # Skip incomplete mirrors
+                if completion < 100:
+                    continue
+
+                # Score: delay (hours) + duration (seconds converted to hours equivalent)
+                score = delay + (duration_avg / 3600)
+
+                filtered_mirrors.append({
+                    "url": mirror.get("url"),
+                    "country": mirror.get("country"),
+                    "country_code": mirror.get("country_code"),
+                    "protocol": mirror.get("protocol"),
+                    "completion_pct": completion,
+                    "delay_hours": delay,
+                    "duration_avg": duration_avg,
+                    "duration_stddev": mirror.get("duration_stddev"),
+                    "score": round(score, 2),
+                    "last_sync": last_sync
+                })
+
+            # Sort by score (lower is better)
+            filtered_mirrors.sort(key=lambda x: x["score"])
+
+            # Limit results
+            suggested_mirrors = filtered_mirrors[:limit]
+
+            logger.info(f"Suggesting {len(suggested_mirrors)} mirrors")
+
+            return {
+                "suggested_count": len(suggested_mirrors),
+                "total_available": len(filtered_mirrors),
+                "country_filter": country,
+                "mirrors": suggested_mirrors
+            }
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error fetching mirror status: {e}")
+        return create_error_response(
+            "HTTPError",
+            f"Failed to fetch mirror status: HTTP {e.response.status_code}"
+        )
+    except httpx.TimeoutException:
+        logger.error("Timeout fetching mirror status")
+        return create_error_response(
+            "Timeout",
+            "Request to mirror status API timed out"
+        )
+    except Exception as e:
+        logger.error(f"Failed to suggest mirrors: {e}")
+        return create_error_response(
+            "MirrorSuggestionError",
+            f"Failed to suggest mirrors: {str(e)}"
+        )
+
+
+async def check_mirrorlist_health() -> Dict[str, Any]:
+    """
+    Verify mirror configuration health.
+    Checks for common issues like no active mirrors, outdated mirrorlist.
+
+    Returns:
+        Dict with health assessment and recommendations
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "This feature is only available on Arch Linux"
+        )
+
+    logger.info("Checking mirrorlist health")
+
+    try:
+        issues = []
+        warnings = []
+        recommendations = []
+
+        # Get active mirrors
+        result = await list_active_mirrors()
+        if "error" in result:
+            return result
+
+        active_mirrors = result.get("active_mirrors", [])
+        
+        # Check: No active mirrors
+        if len(active_mirrors) == 0:
+            issues.append("No active mirrors configured")
+            recommendations.append("Uncomment mirrors in /etc/pacman.d/mirrorlist or use reflector to generate a new mirrorlist")
+
+        # Check: Only one active mirror (no redundancy)
+        elif len(active_mirrors) == 1:
+            warnings.append("Only one active mirror (no redundancy)")
+            recommendations.append("Enable additional mirrors for redundancy")
+
+        # Check: Too many active mirrors (can slow down updates)
+        elif len(active_mirrors) > 10:
+            warnings.append(f"Many active mirrors ({len(active_mirrors)}) may slow down updates")
+            recommendations.append("Consider reducing to 3-5 fastest mirrors")
+
+        # Test mirrors
+        test_result = await test_mirror_speed()
+        if "error" not in test_result:
+            test_results = test_result.get("results", [])
+            
+            # Check: All mirrors failing
+            successful_mirrors = [r for r in test_results if r.get("success", False)]
+            
+            if len(successful_mirrors) == 0:
+                issues.append("All mirrors are unreachable or failing")
+                recommendations.append("Check network connectivity and consider updating mirrorlist")
+            
+            # Check: High latency
+            elif successful_mirrors:
+                avg_latency = sum(m["latency_ms"] for m in successful_mirrors) / len(successful_mirrors)
+                if avg_latency > 1000:
+                    warnings.append(f"High average mirror latency ({avg_latency:.0f}ms)")
+                    recommendations.append("Consider using geographically closer mirrors")
+
+        # Health score
+        health_score = 100
+        health_score -= len(issues) * 40
+        health_score -= len(warnings) * 15
+        health_score = max(0, health_score)
+
+        health_status = "healthy"
+        if health_score < 50:
+            health_status = "critical"
+        elif health_score < 70:
+            health_status = "warning"
+
+        logger.info(f"Mirror health: {health_status} (score: {health_score})")
+
+        return {
+            "health_status": health_status,
+            "health_score": health_score,
+            "issues": issues,
+            "warnings": warnings,
+            "recommendations": recommendations,
+            "active_mirrors_count": len(active_mirrors)
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to check mirror health: {e}")
+        return create_error_response(
+            "HealthCheckError",
+            f"Failed to check mirrorlist health: {str(e)}"
+        )
+

arch_ops_server/news.py

@@ -0,0 +1,288 @@
+# SPDX-License-Identifier: GPL-3.0-only OR MIT
+"""
+Arch Linux news feed integration module.
+Fetches and parses Arch Linux news announcements for critical updates.
+"""
+
+import logging
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from xml.etree import ElementTree as ET
+
+import httpx
+
+from .utils import (
+    IS_ARCH,
+    run_command,
+    create_error_response,
+)
+
+logger = logging.getLogger(__name__)
+
+# Arch Linux news RSS feed URL
+ARCH_NEWS_URL = "https://archlinux.org/feeds/news/"
+
+# Keywords indicating critical/manual intervention required
+CRITICAL_KEYWORDS = [
+    "manual intervention",
+    "action required",
+    "before upgrading",
+    "breaking change",
+    "manual action",
+    "requires manual",
+    "important notice"
+]
+
+
+async def get_latest_news(
+    limit: int = 10,
+    since_date: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Fetch recent Arch Linux news from RSS feed.
+
+    Args:
+        limit: Maximum number of news items to return (default 10)
+        since_date: Optional date in ISO format (YYYY-MM-DD) to filter news
+
+    Returns:
+        Dict with news items (title, date, summary, link)
+    """
+    logger.info(f"Fetching latest Arch Linux news (limit={limit})")
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(ARCH_NEWS_URL)
+            response.raise_for_status()
+
+            # Parse RSS feed
+            root = ET.fromstring(response.content)
+
+            # Find all items (RSS 2.0 format)
+            news_items = []
+            
+            for item in root.findall('.//item')[:limit]:
+                title_elem = item.find('title')
+                link_elem = item.find('link')
+                pub_date_elem = item.find('pubDate')
+                description_elem = item.find('description')
+
+                if title_elem is None or link_elem is None:
+                    continue
+
+                title = title_elem.text
+                link = link_elem.text
+                pub_date = pub_date_elem.text if pub_date_elem is not None else ""
+                
+                # Parse description and strip HTML tags
+                description = ""
+                if description_elem is not None and description_elem.text:
+                    description = re.sub(r'<[^>]+>', '', description_elem.text)
+                    # Truncate to first 300 chars for summary
+                    description = description[:300] + "..." if len(description) > 300 else description
+
+                # Parse date
+                published_date = ""
+                if pub_date:
+                    try:
+                        # Parse RFC 822 date format
+                        dt = datetime.strptime(pub_date, "%a, %d %b %Y %H:%M:%S %z")
+                        published_date = dt.isoformat()
+                    except ValueError:
+                        published_date = pub_date
+
+                # Filter by date if requested
+                if since_date and published_date:
+                    try:
+                        item_date = datetime.fromisoformat(published_date.replace('Z', '+00:00'))
+                        filter_date = datetime.fromisoformat(since_date + "T00:00:00+00:00")
+                        if item_date < filter_date:
+                            continue
+                    except ValueError as e:
+                        logger.warning(f"Failed to parse date for filtering: {e}")
+
+                news_items.append({
+                    "title": title,
+                    "link": link,
+                    "published": published_date,
+                    "summary": description.strip()
+                })
+
+            logger.info(f"Successfully fetched {len(news_items)} news items")
+
+            return {
+                "count": len(news_items),
+                "news": news_items
+            }
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error fetching news: {e}")
+        return create_error_response(
+            "HTTPError",
+            f"Failed to fetch Arch news: HTTP {e.response.status_code}"
+        )
+    except httpx.TimeoutException:
+        logger.error("Timeout fetching Arch news")
+        return create_error_response(
+            "Timeout",
+            "Request to Arch news feed timed out"
+        )
+    except ET.ParseError as e:
+        logger.error(f"Failed to parse RSS feed: {e}")
+        return create_error_response(
+            "ParseError",
+            f"Failed to parse Arch news RSS feed: {str(e)}"
+        )
+    except Exception as e:
+        logger.error(f"Unexpected error fetching news: {e}")
+        return create_error_response(
+            "NewsError",
+            f"Failed to fetch Arch news: {str(e)}"
+        )
+
+
+async def check_critical_news(limit: int = 20) -> Dict[str, Any]:
+    """
+    Check for critical Arch Linux news requiring manual intervention.
+
+    Args:
+        limit: Number of recent news items to check (default 20)
+
+    Returns:
+        Dict with critical news items
+    """
+    logger.info("Checking for critical Arch Linux news")
+
+    result = await get_latest_news(limit=limit)
+
+    if "error" in result:
+        return result
+
+    news_items = result.get("news", [])
+    critical_items = []
+
+    # Scan for critical keywords
+    for item in news_items:
+        title_lower = item["title"].lower()
+        summary_lower = item["summary"].lower()
+
+        # Check if any critical keyword is in title or summary
+        is_critical = any(
+            keyword in title_lower or keyword in summary_lower
+            for keyword in CRITICAL_KEYWORDS
+        )
+
+        if is_critical:
+            # Identify which keywords matched
+            matched_keywords = [
+                keyword for keyword in CRITICAL_KEYWORDS
+                if keyword in title_lower or keyword in summary_lower
+            ]
+
+            critical_items.append({
+                **item,
+                "matched_keywords": matched_keywords,
+                "severity": "critical"
+            })
+
+    logger.info(f"Found {len(critical_items)} critical news items")
+
+    return {
+        "critical_count": len(critical_items),
+        "has_critical": len(critical_items) > 0,
+        "critical_news": critical_items,
+        "checked_items": len(news_items)
+    }
+
+
+async def get_news_since_last_update() -> Dict[str, Any]:
+    """
+    Get news posted since last pacman update.
+    Parses /var/log/pacman.log for last update timestamp.
+
+    Returns:
+        Dict with news items posted after last update
+    """
+    if not IS_ARCH:
+        return create_error_response(
+            "NotSupported",
+            "This feature is only available on Arch Linux"
+        )
+
+    logger.info("Getting news since last pacman update")
+
+    try:
+        # Parse pacman log for last update timestamp
+        pacman_log = Path("/var/log/pacman.log")
+
+        if not pacman_log.exists():
+            return create_error_response(
+                "NotFound",
+                "Pacman log file not found at /var/log/pacman.log"
+            )
+
+        # Find last system update timestamp
+        last_update = None
+
+        with open(pacman_log, 'r') as f:
+            for line in f:
+                # Look for upgrade entries
+                if " upgraded " in line or " installed " in line or "starting full system upgrade" in line:
+                    # Extract timestamp [YYYY-MM-DD HH:MM]
+                    match = re.match(r'\[(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})\]', line)
+                    if match:
+                        date_str = f"{match.group(1)}T{match.group(2)}:00+00:00"
+                        try:
+                            last_update = datetime.fromisoformat(date_str)
+                        except ValueError:
+                            continue
+
+        if last_update is None:
+            logger.warning("Could not determine last update timestamp")
+            return create_error_response(
+                "NotFound",
+                "Could not determine last system update timestamp from pacman log"
+            )
+
+        logger.info(f"Last update: {last_update.isoformat()}")
+
+        # Fetch recent news
+        result = await get_latest_news(limit=30)
+
+        if "error" in result:
+            return result
+
+        news_items = result.get("news", [])
+        news_since_update = []
+
+        for item in news_items:
+            published_str = item.get("published", "")
+            if not published_str:
+                continue
+
+            try:
+                published = datetime.fromisoformat(published_str.replace('Z', '+00:00'))
+                if published > last_update:
+                    news_since_update.append(item)
+            except ValueError as e:
+                logger.warning(f"Failed to parse date: {e}")
+                continue
+
+        logger.info(f"Found {len(news_since_update)} news items since last update")
+
+        return {
+            "last_update": last_update.isoformat(),
+            "news_count": len(news_since_update),
+            "has_news": len(news_since_update) > 0,
+            "news": news_since_update
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to get news since update: {e}")
+        return create_error_response(
+            "NewsError",
+            f"Failed to get news since last update: {str(e)}"
+        )
+