proxy2vpn 0.1.3__py3-none-any.whl

proxy2vpn/docker_ops.py

@@ -0,0 +1,170 @@
+"""Interactions with Docker using the docker SDK."""
+
+from __future__ import annotations
+
+from typing import Iterable, Iterator
+
+import docker
+import requests
+from docker.models.containers import Container
+
+
+def _client() -> docker.DockerClient:
+    """Return a Docker client configured from environment."""
+    return docker.from_env()
+
+
+def create_container(
+    name: str, image: str, command: Iterable[str] | None = None
+) -> Container:
+    """Create a container with the given name and image.
+
+    The image is pulled if it is not available locally.
+    """
+    client = _client()
+    client.images.pull(image)
+    return client.containers.create(image, name=name, command=command, detach=True)
+
+
+def start_container(name: str) -> Container:
+    """Start an existing container by name."""
+    client = _client()
+    container = client.containers.get(name)
+    container.start()
+    return container
+
+
+def stop_container(name: str) -> Container:
+    """Stop a running container by name."""
+    client = _client()
+    container = client.containers.get(name)
+    container.stop()
+    return container
+
+
+def restart_container(name: str) -> Container:
+    """Restart a container by name and return it."""
+    client = _client()
+    container = client.containers.get(name)
+    container.restart()
+    container.reload()
+    return container
+
+
+def remove_container(name: str) -> None:
+    """Remove a container by name."""
+    client = _client()
+    container = client.containers.get(name)
+    container.remove(force=True)
+
+
+def container_logs(name: str, lines: int = 100, follow: bool = False) -> Iterator[str]:
+    """Yield log lines from a container.
+
+    If ``follow`` is ``True`` the generator will yield new log lines as they
+    arrive until the container stops or the caller interrupts.  Otherwise the
+    last ``lines`` lines are returned.
+    """
+
+    client = _client()
+    container = client.containers.get(name)
+    if follow:
+        for line in container.logs(stream=True, follow=True, tail=lines):
+            yield line.decode().rstrip()
+    else:
+        output = container.logs(tail=lines).decode().splitlines()
+        for line in output:
+            yield line
+
+
+def list_containers(all: bool = False) -> list[Container]:
+    """List containers."""
+    client = _client()
+    return client.containers.list(all=all)
+
+
+def get_vpn_containers(all: bool = False) -> list[Container]:
+    """Return containers labeled as VPN services."""
+    client = _client()
+    return client.containers.list(all=all, filters={"label": "vpn.type=vpn"})
+
+
+def start_all_vpn_containers() -> list[tuple[str, bool]]:
+    """Start all VPN containers.
+
+    Returns a list of tuples ``(name, started)`` where ``started`` is ``True``
+    if the container was started by this function and ``False`` if it was
+    already running.
+    """
+
+    containers = get_vpn_containers(all=True)
+    results: list[tuple[str, bool]] = []
+    for container in containers:
+        if container.status != "running":
+            container.start()
+            results.append((container.name, True))
+        else:
+            results.append((container.name, False))
+    return results
+
+
+def stop_all_vpn_containers() -> list[str]:
+    """Stop all running VPN containers.
+
+    Returns a list of container names that were stopped.
+    """
+
+    containers = get_vpn_containers(all=False)
+    results: list[str] = []
+    for container in containers:
+        container.stop()
+        results.append(container.name)
+    return results
+
+
+def get_container_ip(container: Container) -> str:
+    """Return the external IP address for a running container.
+
+    The IP address is retrieved via ``ifconfig.me`` through the proxy exposed on
+    the port specified by the ``vpn.port`` label. If the container is not
+    running, has no port label or the request fails, ``"N/A"`` is returned.
+    """
+
+    port = container.labels.get("vpn.port")
+    if not port or container.status != "running":
+        return "N/A"
+    try:
+        response = requests.get(
+            "https://ifconfig.me",
+            proxies={"http": f"localhost:{port}", "https": f"localhost:{port}"},
+            timeout=5,
+        )
+        return response.text.strip()
+    except Exception:
+        return "N/A"
+
+
+def test_vpn_connection(name: str) -> bool:
+    """Return ``True`` if the VPN proxy for NAME appears to work."""
+
+    client = _client()
+    try:
+        container = client.containers.get(name)
+    except Exception:
+        return False
+    port = container.labels.get("vpn.port")
+    if not port or container.status != "running":
+        return False
+    try:
+        direct = requests.get("https://ifconfig.me", timeout=5).text.strip()
+        proxied = requests.get(
+            "https://ifconfig.me",
+            proxies={
+                "http": f"http://localhost:{port}",
+                "https": f"http://localhost:{port}",
+            },
+            timeout=5,
+        ).text.strip()
+        return proxied != "" and proxied != direct
+    except Exception:
+        return False

proxy2vpn/models.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+
+@dataclass
+class VPNService:
+    name: str
+    port: int
+    provider: str
+    profile: str
+    location: str
+    environment: Dict[str, str]
+    labels: Dict[str, str]
+
+    @classmethod
+    def from_compose_service(cls, name: str, service_def: Dict) -> "VPNService":
+        ports = service_def.get("ports", [])
+        host_port = 0
+        if ports:
+            mapping = str(ports[0])
+            parts = mapping.split(":")
+            if len(parts) >= 3:
+                host_port = int(parts[1])
+            elif len(parts) == 2:
+                host_port = int(parts[0])
+            else:
+                host_port = int(mapping)
+        env_list = service_def.get("environment", [])
+        env_dict: Dict[str, str] = {}
+        for item in env_list:
+            if isinstance(item, str) and "=" in item:
+                k, v = item.split("=", 1)
+                env_dict[k] = v
+        labels = dict(service_def.get("labels", {}))
+        provider = labels.get("vpn.provider", env_dict.get("VPN_SERVICE_PROVIDER", ""))
+        profile = labels.get("vpn.profile", "")
+        location = labels.get("vpn.location", env_dict.get("SERVER_CITIES", ""))
+        return cls(
+            name=name,
+            port=host_port,
+            provider=provider,
+            profile=profile,
+            location=location,
+            environment=env_dict,
+            labels=labels,
+        )
+
+    def to_compose_service(self) -> Dict:
+        env_list = [f"{k}={v}" for k, v in self.environment.items()]
+        service = {
+            "ports": [f"{self.port}:8888/tcp"],
+            "environment": env_list,
+            "labels": self.labels,
+        }
+        return service
+
+
+@dataclass
+class Profile:
+    """Representation of a VPN profile stored as a YAML anchor.
+
+    The profile contains the base configuration used by VPN services.  In
+    the compose file profiles are stored under a key of the form
+    ``x-vpn-base-<name>`` with an anchor ``&vpn-base-<name>``.  Services can
+    then merge the profile using ``<<: *vpn-base-<name>``.
+    """
+
+    name: str
+    env_file: str
+    image: str = "qmcgaw/gluetun"
+    cap_add: List[str] = field(default_factory=lambda: ["NET_ADMIN"])
+    devices: List[str] = field(default_factory=lambda: ["/dev/net/tun:/dev/net/tun"])
+
+    @classmethod
+    def from_anchor(cls, name: str, data: Dict) -> "Profile":
+        """Create a :class:`Profile` from an anchor section."""
+
+        env_files = data.get("env_file", [])
+        env_file = env_files[0] if env_files else ""
+        return cls(
+            name=name,
+            env_file=env_file,
+            image=data.get("image", "qmcgaw/gluetun"),
+            cap_add=list(data.get("cap_add", [])),
+            devices=list(data.get("devices", [])),
+        )
+
+    def to_anchor(self) -> Dict:
+        """Return a dictionary representing the profile configuration."""
+
+        return {
+            "image": self.image,
+            "cap_add": list(self.cap_add),
+            "devices": list(self.devices),
+            "env_file": [self.env_file] if self.env_file else [],
+        }

proxy2vpn/preset_manager.py

@@ -0,0 +1,48 @@
+"""Preset utilities built on top of YAML anchors."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from . import config
+from .compose_manager import ComposeManager
+from .models import VPNService
+
+
+def list_available_presets(compose_file: Path | None = None) -> List[str]:
+    """Return names of available presets (profile anchors)."""
+
+    mgr = ComposeManager(compose_file or config.COMPOSE_FILE)
+    return [profile.name for profile in mgr.list_profiles()]
+
+
+def apply_preset(
+    preset_name: str,
+    service_name: str,
+    port: int,
+    compose_file: Path | None = None,
+) -> None:
+    """Create a VPN service using a preset anchor."""
+
+    mgr = ComposeManager(compose_file or config.COMPOSE_FILE)
+    # Ensure preset exists
+    mgr.get_profile(preset_name)
+    env = {"VPN_SERVICE_PROVIDER": config.DEFAULT_PROVIDER}
+    labels = {
+        "vpn.type": "vpn",
+        "vpn.port": str(port),
+        "vpn.provider": config.DEFAULT_PROVIDER,
+        "vpn.profile": preset_name,
+        "vpn.location": "",
+    }
+    service = VPNService(
+        name=service_name,
+        port=port,
+        provider=config.DEFAULT_PROVIDER,
+        profile=preset_name,
+        location="",
+        environment=env,
+        labels=labels,
+    )
+    mgr.add_service(service)

proxy2vpn/server_manager.py

@@ -0,0 +1,111 @@
+"""Utilities for fetching and caching VPN server lists."""
+
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+from typing import Dict, List
+
+import requests
+import typer
+
+from . import config
+
+
+class ServerManager:
+    """Manage gluetun server list information.
+
+    The server list is downloaded from GitHub and cached locally to avoid
+    repeated network requests.  The cache is considered valid for ``ttl``
+    seconds (24h by default).
+    """
+
+    def __init__(self, cache_dir: Path | None = None, ttl: int = 24 * 3600) -> None:
+        self.cache_dir = cache_dir or config.CACHE_DIR
+        self.cache_file = self.cache_dir / "servers.json"
+        self.ttl = ttl
+        self.data: Dict[str, Dict] | None = None
+
+    # ------------------------------------------------------------------
+    # Fetching and caching
+    # ------------------------------------------------------------------
+
+    def _is_cache_valid(self) -> bool:
+        if not self.cache_file.exists():
+            return False
+        age = time.time() - self.cache_file.stat().st_mtime
+        return age < self.ttl
+
+    def update_servers(self, verify: bool = True) -> Dict[str, Dict]:
+        """Fetch the server list, using the cache when possible.
+
+        Parameters
+        ----------
+        verify:
+            Whether to verify SSL certificates when downloading the server
+            list. Set to ``False`` for troubleshooting.
+        """
+
+        if not self._is_cache_valid():
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+            try:
+                response = requests.get(
+                    config.SERVER_LIST_URL, timeout=30, verify=verify
+                )
+            except requests.exceptions.SSLError:
+                typer.echo(
+                    "Failed to download server list—check network connection or CA certificates",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            response.raise_for_status()
+            self.cache_file.write_text(response.text, encoding="utf-8")
+        with self.cache_file.open("r", encoding="utf-8") as f:
+            self.data = json.load(f)
+        return self.data
+
+    # ------------------------------------------------------------------
+    # Listing helpers
+    # ------------------------------------------------------------------
+
+    def list_providers(self) -> List[str]:
+        data = self.data or self.update_servers()
+        return sorted(k for k in data.keys() if k != "version")
+
+    def list_countries(self, provider: str) -> List[str]:
+        """Return available countries for PROVIDER."""
+
+        data = self.data or self.update_servers()
+        prov = data.get(provider, {})
+        servers = prov.get("servers", [])
+        countries = {srv.get("country") for srv in servers if srv.get("country")}
+        return sorted(countries)
+
+    def list_cities(self, provider: str, country: str) -> List[str]:
+        """Return available cities for PROVIDER in COUNTRY."""
+
+        data = self.data or self.update_servers()
+        prov = data.get(provider, {})
+        servers = prov.get("servers", [])
+        cities = {
+            srv.get("city")
+            for srv in servers
+            if srv.get("country") == country and srv.get("city")
+        }
+        return sorted(cities)
+
+    def validate_location(self, provider: str, location: str) -> bool:
+        """Return ``True`` if LOCATION exists for PROVIDER."""
+
+        data = self.data or self.update_servers()
+        prov = data.get(provider, {})
+        servers = prov.get("servers", [])
+        loc = location.lower()
+        for srv in servers:
+            if (
+                srv.get("city", "").lower() == loc
+                or srv.get("country", "").lower() == loc
+            ):
+                return True
+        return False