proxy2vpn 0.3.0__tar.gz → 0.4.0__tar.gz

{proxy2vpn-0.3.0/src/proxy2vpn.egg-info → proxy2vpn-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proxy2vpn
-Version: 0.3.0
+Version: 0.4.0
 Summary: Proxy2VPN Python utilities
 Author-email: Serhii Khalymon <serhii.khalymon@pm.me>
 License-Expression: MIT
@@ -14,6 +14,8 @@ Requires-Dist: typer
 Requires-Dist: ruamel.yaml
 Requires-Dist: docker
 Requires-Dist: requests
+Requires-Dist: filelock
+Requires-Dist: psutil
 Provides-Extra: dev
 Requires-Dist: towncrier; extra == "dev"
 Dynamic: license-file
@@ -82,6 +84,8 @@ proxy2vpn --help
    ```bash
    proxy2vpn vpn create vpn1 myprofile --port 8888 --provider protonvpn --location "New York"
    proxy2vpn vpn start vpn1
+   # Use --force to recreate the container if it already exists
+   # proxy2vpn vpn start --force vpn1
    ```
 
 5. View status and test connectivity:
@@ -105,7 +109,7 @@ proxy2vpn --help
 ### VPN services
 - `proxy2vpn vpn create NAME PROFILE [--port PORT] [--provider PROVIDER] [--location LOCATION]`
 - `proxy2vpn vpn list [--diagnose] [--ips-only]`
-- `proxy2vpn vpn start [NAME | --all]`
+- `proxy2vpn vpn start [NAME | --all] [--force]`
 - `proxy2vpn vpn stop [NAME | --all]`
 - `proxy2vpn vpn restart [NAME | --all]`
 - `proxy2vpn vpn logs NAME [--lines N] [--follow]`

{proxy2vpn-0.3.0 → proxy2vpn-0.4.0}/README.md

@@ -62,6 +62,8 @@ proxy2vpn --help
    ```bash
    proxy2vpn vpn create vpn1 myprofile --port 8888 --provider protonvpn --location "New York"
    proxy2vpn vpn start vpn1
+   # Use --force to recreate the container if it already exists
+   # proxy2vpn vpn start --force vpn1
    ```
 
 5. View status and test connectivity:
@@ -85,7 +87,7 @@ proxy2vpn --help
 ### VPN services
 - `proxy2vpn vpn create NAME PROFILE [--port PORT] [--provider PROVIDER] [--location LOCATION]`
 - `proxy2vpn vpn list [--diagnose] [--ips-only]`
-- `proxy2vpn vpn start [NAME | --all]`
+- `proxy2vpn vpn start [NAME | --all] [--force]`
 - `proxy2vpn vpn stop [NAME | --all]`
 - `proxy2vpn vpn restart [NAME | --all]`
 - `proxy2vpn vpn logs NAME [--lines N] [--follow]`

{proxy2vpn-0.3.0 → proxy2vpn-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "proxy2vpn"
-version = "0.3.0"
+version = "0.4.0"
 description = "Proxy2VPN Python utilities"
 authors = [{ name = "Serhii Khalymon", email = "serhii.khalymon@pm.me" }]
 readme = "README.md"
@@ -21,6 +21,8 @@ dependencies = [
     "ruamel.yaml",
     "docker",
     "requests",
+    "filelock",
+    "psutil",
 ]
 
 [project.optional-dependencies]

{proxy2vpn-0.3.0 → proxy2vpn-0.4.0}/src/proxy2vpn/cli.py

@@ -14,6 +14,9 @@ from .compose_manager import ComposeManager
 from .models import Profile, VPNService
 from .server_manager import ServerManager
 from .compose_validator import validate_compose
+from .utils import abort
+from .validators import sanitize_name, sanitize_path, validate_port
+from .logging_utils import configure_logging, get_logger
 
 app = HelpfulTyper(help="proxy2vpn command line interface")
 
@@ -31,12 +34,18 @@ app.add_typer(system_app, name="system")
 app.add_typer(preset_app, name="preset")
 app.add_typer(bulk_app, name="bulk", hidden=True)
 
+logger = get_logger(__name__)
+
 
 @app.callback(invoke_without_command=True)
 def main(
     ctx: typer.Context,
     compose_file: Path = typer.Option(
-        config.COMPOSE_FILE, "--compose-file", "-f", help="Path to compose file"
+        config.COMPOSE_FILE,
+        "--compose-file",
+        "-f",
+        help="Path to compose file",
+        callback=sanitize_path,
     ),
     version: bool = typer.Option(
         False,
@@ -47,6 +56,7 @@ def main(
     ),
 ):
     """Store global options in context."""
+    configure_logging()
     if version:
         from . import __version__
 
@@ -56,6 +66,10 @@ def main(
     ctx.obj = ctx.obj or {}
     ctx.obj["compose_file"] = compose_file
 
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
 
 # ---------------------------------------------------------------------------
 # System commands
@@ -72,14 +86,18 @@ def system_init(
     """Generate an initial compose.yml file."""
 
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
+    overwrite = force
+    if compose_file.exists() and not force:
+        typer.confirm(f"Overwrite existing '{compose_file}'?", abort=True)
+        overwrite = True
     try:
-        ComposeManager.create_initial_compose(compose_file, force=force)
+        ComposeManager.create_initial_compose(compose_file, force=overwrite)
+        logger.info("compose_initialized", extra={"file": str(compose_file)})
     except FileExistsError:
-        typer.echo(
-            f"Compose file '{compose_file}' already exists. Use --force to overwrite.",
-            err=True,
+        abort(
+            f"Compose file '{compose_file}' already exists",
+            "Use --force to overwrite",
         )
-        raise typer.Exit(1)
     typer.echo(f"Created '{compose_file}'.")
 
 
@@ -89,13 +107,23 @@ def system_init(
 
 
 @profile_app.command("create")
-def profile_create(ctx: typer.Context, name: str, env_file: Path):
+def profile_create(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., callback=sanitize_name),
+    env_file: Path = typer.Argument(..., callback=sanitize_path),
+):
     """Create a new VPN profile."""
 
+    if not env_file.exists():
+        abort(
+            f"Environment file '{env_file}' not found",
+            "Create the file before creating the profile",
+        )
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
     profile = Profile(name=name, env_file=str(env_file))
     manager.add_profile(profile)
+    logger.info("profile_created", extra={"name": name})
     typer.echo(f"Profile '{name}' created.")
 
 
@@ -110,11 +138,21 @@ def profile_list(ctx: typer.Context):
 
 
 @profile_app.command("delete")
-def profile_delete(ctx: typer.Context, name: str):
+def profile_delete(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., callback=sanitize_name),
+    force: bool = typer.Option(False, "--force", "-f", help="Do not prompt"),
+):
     """Delete a profile by NAME."""
 
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
+    try:
+        manager.get_profile(name)
+    except KeyError:
+        abort(f"Profile '{name}' not found")
+    if not force:
+        typer.confirm(f"Delete profile '{name}'?", abort=True)
     manager.remove_profile(name)
     typer.echo(f"Profile '{name}' deleted.")
 
@@ -127,9 +165,13 @@ def profile_delete(ctx: typer.Context, name: str):
 @vpn_app.command("create")
 def vpn_create(
     ctx: typer.Context,
-    name: str,
-    profile: str,
-    port: int = typer.Option(0, help="Host port to expose; 0 for auto"),
+    name: str = typer.Argument(..., callback=sanitize_name),
+    profile: str = typer.Argument(..., callback=sanitize_name),
+    port: int = typer.Option(
+        0,
+        callback=validate_port,
+        help="Host port to expose; 0 for auto",
+    ),
     provider: str = typer.Option(config.DEFAULT_PROVIDER),
     location: str = typer.Option("", help="Optional location, e.g. city"),
 ):
@@ -137,9 +179,17 @@ def vpn_create(
 
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
+    try:
+        manager.get_profile(profile)
+    except KeyError:
+        abort(
+            f"Profile '{profile}' not found",
+            "Create it with 'proxy2vpn profile create'",
+        )
     if port == 0:
         port = manager.next_available_port(config.DEFAULT_PORT_START)
     env = {"VPN_SERVICE_PROVIDER": provider}
+    location = location.strip()
     if location:
         env["SERVER_CITIES"] = location
     labels = {
@@ -199,7 +249,8 @@ def vpn_list(
         header += f" {'HEALTH':<7}"
     typer.echo(header)
     typer.echo("-" * len(header))
-    for svc in services:
+    iterator = typer.progressbar(services, label="Checking") if diagnose else services
+    for svc in iterator:
         container = containers.get(svc.name)
         if container:
             status = container.status
@@ -221,60 +272,97 @@ def vpn_list(
 @vpn_app.command("start")
 def vpn_start(
     ctx: typer.Context,
-    name: str | None = typer.Argument(None),
+    name: str | None = typer.Argument(
+        None, callback=lambda v: sanitize_name(v) if v else None
+    ),
     all: bool = typer.Option(False, "--all", help="Start all VPN services"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Recreate container if it already exists"
+    ),
 ):
     """Start one or all VPN containers."""
 
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
     if all and name is not None:
-        typer.echo("Cannot specify NAME when using --all", err=True)
-        raise typer.Exit(1)
+        abort("Cannot specify NAME when using --all")
     if all:
         from .docker_ops import start_all_vpn_containers
 
-        results = start_all_vpn_containers()
+        results = start_all_vpn_containers(manager, force=force)
         for svc_name, started in results:
             if started:
-                typer.echo(f"\u2713 Started {svc_name}")
+                if force:
+                    typer.echo(f"\u2713 Recreated and started {svc_name}")
+                else:
+                    typer.echo(f"\u2713 Started {svc_name}")
             else:
                 typer.echo(f"\u2192 {svc_name} already running")
         return
 
     if name is None:
-        typer.echo("Specify a service NAME or use --all", err=True)
-        raise typer.Exit(1)
+        abort("Specify a service NAME or use --all")
     try:
         manager.get_service(name)
     except KeyError:
-        typer.echo(f"Service '{name}' not found.", err=True)
-        raise typer.Exit(1)
+        abort(f"Service '{name}' not found")
 
-    from .docker_ops import start_container, analyze_container_logs
+    from .docker_ops import (
+        start_container,
+        analyze_container_logs,
+        create_vpn_container,
+        recreate_vpn_container,
+    )
     from .diagnostics import DiagnosticAnalyzer
 
+    svc = manager.get_service(name)
+    profile = manager.get_profile(svc.profile)
+    if force:
+        try:
+            recreate_vpn_container(svc, profile)
+            start_container(name)
+            typer.echo(f"Recreated and started '{name}'.")
+        except APIError as exc:
+            analyzer = DiagnosticAnalyzer()
+            results = analyze_container_logs(name, analyzer=analyzer)
+            if results:
+                typer.echo("Diagnostic hints:", err=True)
+                for res in results:
+                    typer.echo(f" - {res.message}: {res.recommendation}", err=True)
+            abort(f"Failed to start '{name}': {exc.explanation}")
+        return
     try:
         start_container(name)
         typer.echo(f"Started '{name}'.")
     except NotFound:
-        typer.echo(f"Container '{name}' does not exist.", err=True)
-        raise typer.Exit(1)
+        try:
+            create_vpn_container(svc, profile)
+            start_container(name)
+            typer.echo(f"Created and started '{name}'.")
+        except APIError as exc:
+            analyzer = DiagnosticAnalyzer()
+            results = analyze_container_logs(name, analyzer=analyzer)
+            if results:
+                typer.echo("Diagnostic hints:", err=True)
+                for res in results:
+                    typer.echo(f" - {res.message}: {res.recommendation}", err=True)
+            abort(f"Failed to start '{name}': {exc.explanation}")
     except APIError as exc:
-        typer.echo(f"Failed to start '{name}': {exc.explanation}", err=True)
         analyzer = DiagnosticAnalyzer()
         results = analyze_container_logs(name, analyzer=analyzer)
         if results:
             typer.echo("Diagnostic hints:", err=True)
             for res in results:
                 typer.echo(f" - {res.message}: {res.recommendation}", err=True)
-        raise typer.Exit(1)
+        abort(f"Failed to start '{name}': {exc.explanation}")
 
 
 @vpn_app.command("stop")
 def vpn_stop(
     ctx: typer.Context,
-    name: str | None = typer.Argument(None),
+    name: str | None = typer.Argument(
+        None, callback=lambda v: sanitize_name(v) if v else None
+    ),
     all: bool = typer.Option(False, "--all", help="Stop all VPN services"),
 ):
     """Stop one or all VPN containers."""
@@ -282,8 +370,7 @@ def vpn_stop(
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
     if all and name is not None:
-        typer.echo("Cannot specify NAME when using --all", err=True)
-        raise typer.Exit(1)
+        abort("Cannot specify NAME when using --all")
     if all:
         from .docker_ops import stop_all_vpn_containers
 
@@ -293,13 +380,11 @@ def vpn_stop(
         return
 
     if name is None:
-        typer.echo("Specify a service NAME or use --all", err=True)
-        raise typer.Exit(1)
+        abort("Specify a service NAME or use --all")
     try:
         manager.get_service(name)
     except KeyError:
-        typer.echo(f"Service '{name}' not found.", err=True)
-        raise typer.Exit(1)
+        abort(f"Service '{name}' not found")
 
     from .docker_ops import stop_container, analyze_container_logs
     from .diagnostics import DiagnosticAnalyzer
@@ -308,23 +393,23 @@ def vpn_stop(
         stop_container(name)
         typer.echo(f"Stopped '{name}'.")
     except NotFound:
-        typer.echo(f"Container '{name}' does not exist.", err=True)
-        raise typer.Exit(1)
+        abort(f"Container '{name}' does not exist")
     except APIError as exc:
-        typer.echo(f"Failed to stop '{name}': {exc.explanation}", err=True)
         analyzer = DiagnosticAnalyzer()
         results = analyze_container_logs(name, analyzer=analyzer)
         if results:
             typer.echo("Diagnostic hints:", err=True)
             for res in results:
                 typer.echo(f" - {res.message}: {res.recommendation}", err=True)
-        raise typer.Exit(1)
+        abort(f"Failed to stop '{name}': {exc.explanation}")
 
 
 @vpn_app.command("restart")
 def vpn_restart(
     ctx: typer.Context,
-    name: str | None = typer.Argument(None),
+    name: str | None = typer.Argument(
+        None, callback=lambda v: sanitize_name(v) if v else None
+    ),
     all: bool = typer.Option(False, "--all", help="Restart all VPN services"),
 ):
     """Restart one or all VPN containers."""
@@ -332,8 +417,7 @@ def vpn_restart(
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
     if all and name is not None:
-        typer.echo("Cannot specify NAME when using --all", err=True)
-        raise typer.Exit(1)
+        abort("Cannot specify NAME when using --all")
     if all:
         from .docker_ops import get_vpn_containers, restart_container
 
@@ -351,13 +435,11 @@ def vpn_restart(
         return
 
     if name is None:
-        typer.echo("Specify a service NAME or use --all", err=True)
-        raise typer.Exit(1)
+        abort("Specify a service NAME or use --all")
     try:
         manager.get_service(name)
     except KeyError:
-        typer.echo(f"Service '{name}' not found.", err=True)
-        raise typer.Exit(1)
+        abort(f"Service '{name}' not found")
 
     from .docker_ops import restart_container, analyze_container_logs
     from .diagnostics import DiagnosticAnalyzer
@@ -366,35 +448,33 @@ def vpn_restart(
         restart_container(name)
         typer.echo(f"Restarted '{name}'.")
     except NotFound:
-        typer.echo(f"Container '{name}' does not exist.", err=True)
-        raise typer.Exit(1)
+        abort(f"Container '{name}' does not exist")
     except APIError as exc:
-        typer.echo(f"Failed to restart '{name}': {exc.explanation}", err=True)
         analyzer = DiagnosticAnalyzer()
         results = analyze_container_logs(name, analyzer=analyzer)
         if results:
             typer.echo("Diagnostic hints:", err=True)
             for res in results:
                 typer.echo(f" - {res.message}: {res.recommendation}", err=True)
-        raise typer.Exit(1)
+        abort(f"Failed to restart '{name}': {exc.explanation}")
 
 
 @vpn_app.command("logs")
 def vpn_logs(
     ctx: typer.Context,
-    name: str,
+    name: str = typer.Argument(..., callback=sanitize_name),
     lines: int = typer.Option(100, "--lines", help="Number of lines to show"),
     follow: bool = typer.Option(False, "--follow", help="Follow log output"),
 ):
     """Show logs for a VPN container."""
-
+    if lines <= 0:
+        abort("LINES must be positive")
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
     manager = ComposeManager(compose_file)
     try:
         manager.get_service(name)
     except KeyError:
-        typer.echo(f"Service '{name}' not found.", err=True)
-        raise typer.Exit(1)
+        abort(f"Service '{name}' not found")
 
     from .docker_ops import container_logs
 
@@ -402,14 +482,15 @@ def vpn_logs(
         for line in container_logs(name, lines=lines, follow=follow):
             typer.echo(line)
     except NotFound:
-        typer.echo(f"Container '{name}' does not exist.", err=True)
-        raise typer.Exit(1)
+        abort(f"Container '{name}' does not exist")
 
 
 @vpn_app.command("delete")
 def vpn_delete(
     ctx: typer.Context,
-    name: str | None = typer.Argument(None),
+    name: str | None = typer.Argument(
+        None, callback=lambda v: sanitize_name(v) if v else None
+    ),
     all: bool = typer.Option(False, "--all", help="Delete all VPN services"),
     force: bool = typer.Option(False, "--force", "-f", help="Do not prompt"),
 ):
@@ -420,8 +501,7 @@ def vpn_delete(
     from .docker_ops import remove_container, stop_container
 
     if all and name is not None:
-        typer.echo("Cannot specify NAME when using --all", err=True)
-        raise typer.Exit(1)
+        abort("Cannot specify NAME when using --all")
     if all:
         services = manager.list_services()
         if not force and not typer.confirm("Delete all services?"):
@@ -440,13 +520,11 @@ def vpn_delete(
         return
 
     if name is None:
-        typer.echo("Specify a service NAME or use --all", err=True)
-        raise typer.Exit(1)
+        abort("Specify a service NAME or use --all")
     try:
         manager.get_service(name)
     except KeyError:
-        typer.echo(f"Service '{name}' not found.", err=True)
-        raise typer.Exit(1)
+        abort(f"Service '{name}' not found")
 
     if not force and not typer.confirm(f"Delete service '{name}'?"):
         raise typer.Exit()
@@ -465,7 +543,9 @@ def vpn_delete(
 
 
 @vpn_app.command("test")
-def vpn_test(ctx: typer.Context, name: str):
+def vpn_test(
+    ctx: typer.Context, name: str = typer.Argument(..., callback=sanitize_name)
+):
     """Test that a VPN service proxy is working."""
 
     compose_file: Path = ctx.obj.get("compose_file", config.COMPOSE_FILE)
@@ -473,16 +553,14 @@ def vpn_test(ctx: typer.Context, name: str):
     try:
         manager.get_service(name)
     except KeyError:
-        typer.echo(f"Service '{name}' not found.", err=True)
-        raise typer.Exit(1)
+        abort(f"Service '{name}' not found")
 
     from .docker_ops import test_vpn_connection
 
     if test_vpn_connection(name):
         typer.echo("VPN connection is active.")
     else:
-        typer.echo("VPN connection failed.", err=True)
-        raise typer.Exit(1)
+        abort("VPN connection failed", "Check container logs")
 
 
 # ---------------------------------------------------------------------------
@@ -497,7 +575,8 @@ def bulk_up():
     typer.echo("Deprecated: use 'vpn start --all' instead.", err=True)
     from .docker_ops import start_all_vpn_containers
 
-    results = start_all_vpn_containers()
+    manager = ComposeManager(config.COMPOSE_FILE)
+    results = start_all_vpn_containers(manager)
     for name, started in results:
         if started:
             typer.echo(f"\u2713 Started {name}")

{proxy2vpn-0.3.0 → proxy2vpn-0.4.0}/src/proxy2vpn/compose_manager.py

@@ -2,11 +2,15 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import Any, Dict, List
+import os
+import shutil
 
+from filelock import FileLock
 from ruamel.yaml import YAML
 from ruamel.yaml.comments import CommentedMap
 
 from .models import Profile, VPNService
+from .compose_validator import validate_compose
 
 # Minimal compose template used when initializing a new project
 INITIAL_COMPOSE_TEMPLATE = """\
@@ -28,6 +32,7 @@ class ComposeManager:
     def __init__(self, compose_path: Path) -> None:
         self.compose_path = compose_path
         self.yaml = YAML()
+        self.lock = FileLock(str(compose_path) + ".lock")
         self.data: Dict[str, Any] = self._load()
 
     def _load(self) -> Dict[str, Any]:
@@ -35,8 +40,23 @@ class ComposeManager:
             raise FileNotFoundError(
                 f"compose file '{self.compose_path}' not found. Run 'proxy2vpn init' to create it."
             )
-        with self.compose_path.open("r", encoding="utf-8") as f:
-            return self.yaml.load(f)
+        backup_path = self.compose_path.with_suffix(self.compose_path.suffix + ".bak")
+        with self.lock:
+            try:
+                with self.compose_path.open("r", encoding="utf-8") as f:
+                    data = self.yaml.load(f)
+                if not isinstance(data, dict):
+                    raise ValueError("compose file does not contain a mapping")
+                # basic validation: ensure YAML structure can be parsed
+                validate_compose(self.compose_path)
+                return data
+            except Exception:
+                if backup_path.exists():
+                    with backup_path.open("r", encoding="utf-8") as f:
+                        data = self.yaml.load(f)
+                    shutil.copy2(backup_path, self.compose_path)
+                    return data
+                raise
 
     @staticmethod
     def create_initial_compose(path: Path, force: bool = False) -> None:
@@ -145,5 +165,22 @@ class ComposeManager:
         return port
 
     def save(self) -> None:
-        with self.compose_path.open("w", encoding="utf-8") as f:
-            self.yaml.dump(self.data, f)
+        backup_path = self.compose_path.with_suffix(self.compose_path.suffix + ".bak")
+        tmp_path = self.compose_path.with_suffix(self.compose_path.suffix + ".tmp")
+        with self.lock:
+            try:
+                if self.compose_path.exists():
+                    shutil.copy2(self.compose_path, backup_path)
+                with tmp_path.open("w", encoding="utf-8") as f:
+                    self.yaml.dump(self.data, f)
+                os.replace(tmp_path, self.compose_path)
+            except Exception:
+                if backup_path.exists():
+                    shutil.copy2(backup_path, self.compose_path)
+                raise
+            finally:
+                if tmp_path.exists():
+                    try:
+                        tmp_path.unlink()
+                    except FileNotFoundError:
+                        pass