modelmux-cli 0.1.0__py3-none-any.whl

modelmux_cli/docker.py

@@ -0,0 +1,340 @@
+"""The ONLY module that runs other programs: the ``docker`` CLI.
+
+- Commands are argument lists, never shell strings.
+- Every call has a timeout.
+- Docker's raw output is shown only with --verbose (and redacted there);
+  failures become ``DockerError``s with a plain message and a next step.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable, Iterator, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from modelmux_cli.console import Console
+from modelmux_cli.errors import DockerError
+
+DEFAULT_TIMEOUT = 60.0
+PULL_TIMEOUT = 1800.0
+
+Runner = Callable[..., "subprocess.CompletedProcess[str]"]
+
+
+@dataclass(frozen=True)
+class Result:
+    args: tuple[str, ...]
+    returncode: int
+    stdout: str
+    stderr: str
+
+    @property
+    def ok(self) -> bool:
+        return self.returncode == 0
+
+
+def _start_docker_hint(platform: str) -> str:
+    if platform in ("darwin", "win32"):
+        return "Start Docker Desktop and wait until it says it is running, then try again."
+    return "Start the Docker service (for example: sudo systemctl start docker), then try again."
+
+
+def _install_hint(platform: str) -> str:
+    if platform in ("darwin", "win32"):
+        return "Install Docker Desktop: https://docs.docker.com/desktop/"
+    return "Install Docker Engine: https://docs.docker.com/engine/install/"
+
+
+# (pattern in Docker's stderr, message, hint factory)
+_CLASSIFIERS: tuple[tuple[re.Pattern[str], str, Callable[[str], str]], ...] = (
+    (
+        re.compile(r"permission denied while trying to connect", re.I),
+        "Your user is not allowed to use Docker.",
+        lambda _p: (
+            "Add yourself to the docker group (sudo usermod -aG docker $USER), "
+            "then log out and back in."
+        ),
+    ),
+    (
+        re.compile(
+            r"cannot connect to the docker daemon|is the docker daemon running|error during "
+            r"connect|docker_engine.*(cannot find|not found)|failed to connect to the docker API",
+            re.I,
+        ),
+        "Docker is installed but not running.",
+        _start_docker_hint,
+    ),
+    (
+        re.compile(
+            r"'compose' is not a docker command|unknown command.*compose|unknown shorthand"
+            r" flag: 'f' in -f",
+            re.I,
+        ),
+        "Docker Compose v2 is not available.",
+        lambda _p: "Install the Docker Compose plugin: https://docs.docker.com/compose/install/",
+    ),
+    (
+        re.compile(r"port is already allocated|address already in use|bind: .*in use", re.I),
+        "A port ModelMux needs is already in use.",
+        lambda _p: "Run 'modelmux doctor' to see which port, or choose another with --port.",
+    ),
+    (
+        re.compile(
+            r"manifest unknown|manifest for .* not found|not found: manifest|"
+            r"failed to resolve reference .*: not found",
+            re.I,
+        ),
+        "The ModelMux image for this version was not found.",
+        lambda _p: (
+            "Check for a newer modelmux-cli (pipx upgrade modelmux-cli), or run 'modelmux doctor'."
+        ),
+    ),
+    (
+        # GHCR answers a bare "denied" for images that do not exist or are private.
+        re.compile(r"pull access denied|unauthorized|error from registry: denied|denied: ", re.I),
+        "The image registry refused access (the image may not exist or may be private).",
+        lambda _p: (
+            "Check that you can reach ghcr.io and are not logged in with expired "
+            "credentials (docker logout ghcr.io)."
+        ),
+    ),
+    (
+        re.compile(
+            r"tls handshake timeout|i/o timeout|no such host|dial tcp|network is unreachable|"
+            r"proxyconnect|connection refused|temporary failure in name resolution",
+            re.I,
+        ),
+        "Docker could not reach the internet.",
+        lambda _p: (
+            "Check your connection or proxy (HTTPS_PROXY, and Docker Desktop's proxy "
+            "settings), then try again."
+        ),
+    ),
+    (
+        re.compile(r"no space left on device", re.I),
+        "Docker has run out of disk space.",
+        lambda _p: "Free space with 'docker system prune' (it removes unused images), then retry.",
+    ),
+)
+
+
+def classify(stderr: str, command: str, platform: str | None = None) -> DockerError:
+    platform = platform or sys.platform
+    for pattern, message, hint in _CLASSIFIERS:
+        if pattern.search(stderr):
+            return DockerError(message, hint=hint(platform))
+    return DockerError(
+        f"Docker command failed: docker {command}.",
+        hint="Run again with --verbose to see Docker's output.",
+    )
+
+
+@contextlib.contextmanager
+def _raw_terminal(in_fd: int, master: int) -> Iterator[None]:
+    """Give the pseudo-terminal our window size and put our terminal in raw mode."""
+    if sys.platform == "win32":
+        raise OSError("pseudo-terminals need Linux or macOS")
+    if not os.isatty(in_fd):
+        yield
+        return
+    import fcntl  # noqa: PLC0415 - POSIX only
+    import termios  # noqa: PLC0415
+    import tty  # noqa: PLC0415
+
+    with contextlib.suppress(OSError):
+        size = fcntl.ioctl(in_fd, termios.TIOCGWINSZ, b"\0" * 8)
+        fcntl.ioctl(master, termios.TIOCSWINSZ, size)
+    saved = termios.tcgetattr(in_fd)
+    tty.setraw(in_fd)
+    try:
+        yield
+    finally:
+        termios.tcsetattr(in_fd, termios.TCSADRAIN, saved)
+
+
+def _relay(
+    master: int,
+    in_fd: int,
+    out_fd: int,
+    on_output: Callable[[bytes], bytes | None],
+    timeout: float,
+) -> None:
+    """Copy keystrokes to the program and its output to us until it closes."""
+    import select  # noqa: PLC0415
+    import time  # noqa: PLC0415
+
+    deadline = time.monotonic() + timeout
+    watch = [master, in_fd]
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise TimeoutError
+        ready, _, _ = select.select(watch, [], [], min(remaining, 0.5))
+        if master in ready:
+            try:
+                data = os.read(master, 4096)
+            except OSError:  # EIO: the program closed its terminal
+                return
+            if not data:
+                return
+            os.write(out_fd, data)
+            if extra := on_output(data):
+                os.write(out_fd, extra)
+        if in_fd in ready:
+            typed = os.read(in_fd, 1024)
+            if typed:
+                os.write(master, typed)
+            else:
+                watch = [master]  # our stdin closed; keep relaying output
+
+
+class Docker:
+    def __init__(
+        self,
+        console: Console,
+        *,
+        runner: Runner | None = None,
+        which: Callable[[str], str | None] = shutil.which,
+        platform: str | None = None,
+    ) -> None:
+        self.console = console
+        self._runner: Runner = runner or subprocess.run
+        self._which = which
+        self.platform = platform or sys.platform
+        self._binary: str | None = None
+
+    @property
+    def binary(self) -> str:
+        if self._binary is None:
+            found = self._which("docker")
+            if found is None:
+                raise DockerError("Docker is not installed.", hint=_install_hint(self.platform))
+            self._binary = found
+        return self._binary
+
+    def _argv(self, args: Sequence[str]) -> list[str]:
+        for arg in args:
+            if not isinstance(arg, str) or "\x00" in arg:
+                raise DockerError("Internal error: invalid docker argument.")
+        return [self.binary, *args]
+
+    def run(
+        self,
+        *args: str,
+        timeout: float = DEFAULT_TIMEOUT,
+        input_text: str | None = None,
+        check: bool = True,
+    ) -> Result:
+        """Run ``docker <args>`` and capture its output."""
+        argv = self._argv(args)
+        self.console.detail("$ docker " + shlex.join(args))
+        kwargs: dict[str, Any] = {
+            "capture_output": True,
+            "text": True,
+            "encoding": "utf-8",
+            "errors": "replace",
+            "timeout": timeout,
+            "check": False,
+        }
+        if input_text is not None:
+            kwargs["input"] = input_text
+        else:
+            kwargs["stdin"] = subprocess.DEVNULL
+        try:
+            proc = self._runner(argv, **kwargs)
+        except FileNotFoundError:
+            raise DockerError(
+                "Docker is not installed.", hint=_install_hint(self.platform)
+            ) from None
+        except PermissionError:
+            raise DockerError(
+                "The docker command cannot be executed.", hint=f"Check permissions of {argv[0]}."
+            ) from None
+        except subprocess.TimeoutExpired:
+            raise DockerError(
+                f"Docker did not finish 'docker {args[0] if args else ''}' in time.",
+                hint="Docker may be busy or stuck; check Docker is healthy and try again.",
+            ) from None
+        result = Result(tuple(args), proc.returncode, proc.stdout or "", proc.stderr or "")
+        if result.stdout.strip():
+            self.console.detail(result.stdout.rstrip())
+        if result.stderr.strip():
+            self.console.detail(result.stderr.rstrip())
+        if check and not result.ok:
+            raise classify(result.stderr, args[0] if args else "", self.platform)
+        return result
+
+    def passthrough(self, *args: str, timeout: float | None = None) -> int:
+        """Run ``docker <args>`` attached to this terminal (logs -f, interactive login).
+
+        Output is not captured, so it is the user's own Docker output.
+        """
+        argv = self._argv(args)
+        self.console.detail("$ docker " + shlex.join(args))
+        try:
+            return self._runner(argv, timeout=timeout, check=False).returncode
+        except FileNotFoundError:
+            raise DockerError(
+                "Docker is not installed.", hint=_install_hint(self.platform)
+            ) from None
+        except subprocess.TimeoutExpired:
+            raise DockerError("Docker did not finish in time.", hint="Try again.") from None
+
+    def run_pty(
+        self,
+        *args: str,
+        on_output: Callable[[bytes], bytes | None],
+        timeout: float,
+        stdin_fd: int | None = None,
+        stdout_fd: int | None = None,
+    ) -> int:
+        """POSIX: run ``docker <args>`` on a new pseudo-terminal and relay it.
+
+        Keystrokes go straight from our terminal to the program, and its
+        output straight to our terminal; neither is stored. ``on_output`` sees
+        each output chunk and may return extra bytes to display (for example
+        "opened your browser"). Raises ``TimeoutError`` after ``timeout``.
+        """
+        if sys.platform == "win32":
+            raise OSError("pseudo-terminals need Linux or macOS")
+        import pty  # noqa: PLC0415 - POSIX only
+        import signal  # noqa: PLC0415
+
+        argv = self._argv(args)
+        self.console.detail("$ docker " + shlex.join(args))
+        in_fd = sys.stdin.fileno() if stdin_fd is None else stdin_fd
+        out_fd = sys.stdout.fileno() if stdout_fd is None else stdout_fd
+        pid, master = pty.fork()
+        if pid == 0:  # pragma: no cover - child process
+            try:
+                os.execv(argv[0], argv)
+            finally:
+                os._exit(127)
+        try:
+            with _raw_terminal(in_fd, master):
+                _relay(master, in_fd, out_fd, on_output, timeout)
+            _, status = os.waitpid(pid, 0)
+            return os.waitstatus_to_exitcode(status)
+        finally:
+            with contextlib.suppress(ChildProcessError, ProcessLookupError, OSError):
+                if os.waitpid(pid, os.WNOHANG) == (0, 0):
+                    os.kill(pid, signal.SIGTERM)
+                    os.waitpid(pid, 0)
+            os.close(master)
+
+    def compose(self, project: str, file: Path, *args: str, **kwargs: Any) -> Result:
+        return self.run("compose", "-p", project, "-f", str(file), *args, **kwargs)
+
+    def check_available(self) -> str:
+        """Docker is installed, running, and has Compose v2. Returns the server version."""
+        server = self.run("version", "--format", "{{.Server.Version}}").stdout.strip()
+        self.run("compose", "version", "--short")
+        return server

modelmux_cli/errors.py

@@ -0,0 +1,35 @@
+"""Errors the CLI reports to the user.
+
+Every failure is a ``CliError``: a plain message saying what went wrong, an
+optional hint saying what to do next, and an exit code. ``main`` is the only
+place that prints them.
+"""
+
+from __future__ import annotations
+
+EXIT_OK = 0
+EXIT_FAILURE = 1
+EXIT_USAGE = 2
+EXIT_DOCKER = 3
+EXIT_INTERRUPTED = 130
+
+
+class CliError(Exception):
+    exit_code = EXIT_FAILURE
+
+    def __init__(self, message: str, *, hint: str | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.hint = hint
+
+
+class UsageError(CliError):
+    """The command was used incorrectly."""
+
+    exit_code = EXIT_USAGE
+
+
+class DockerError(CliError):
+    """Docker is missing, stopped, or a Docker command failed."""
+
+    exit_code = EXIT_DOCKER

modelmux_cli/files.py

@@ -0,0 +1,42 @@
+"""Small, safe file writes: atomic, and private (0600) from the first byte."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import secrets
+from pathlib import Path
+
+PRIVATE_MODE = 0o600
+
+
+def write_private(path: Path, data: str) -> None:
+    """Atomically replace ``path`` with ``data``, created with mode 0600.
+
+    The temporary file is created with 0600 (never readable by others, even
+    briefly) in the same directory, then renamed over the target.
+    """
+    tmp = path.with_name(f".{path.name}.{secrets.token_hex(6)}.tmp")
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0)
+    fd = os.open(tmp, flags, PRIVATE_MODE)
+    try:
+        with os.fdopen(fd, "wb") as fh:
+            fh.write(data.encode("utf-8"))
+            fh.flush()
+            os.fsync(fh.fileno())
+        os.replace(tmp, path)
+    except BaseException:
+        with contextlib.suppress(OSError):
+            tmp.unlink()
+        raise
+
+
+def tighten(path: Path) -> bool:
+    """Make an existing file 0600 on POSIX. Returns True if it had to change."""
+    if os.name != "posix":
+        return False
+    mode = path.stat().st_mode & 0o777
+    if mode != PRIVATE_MODE:
+        path.chmod(PRIVATE_MODE)
+        return True
+    return False

modelmux_cli/health.py

@@ -0,0 +1,60 @@
+"""Talk to a running ModelMux server over HTTP (localhost only)."""
+
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.request
+from collections.abc import Callable
+from typing import Any
+
+LOCALHOST = "127.0.0.1"
+
+
+def base_url(port: int) -> str:
+    return f"http://{LOCALHOST}:{port}"
+
+
+def get_json(
+    port: int, path: str, *, timeout: float = 3.0, api_key: str | None = None
+) -> tuple[int, Any]:
+    """GET ``path`` on the local server. Returns (status, body); status 0 if unreachable."""
+    request = urllib.request.Request(base_url(port) + path)  # noqa: S310 - fixed http://127.0.0.1
+    if api_key is not None:
+        request.add_header("Authorization", f"Bearer {api_key}")
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:  # noqa: S310
+            return response.status, json.loads(response.read() or b"null")
+    except urllib.error.HTTPError as exc:
+        try:
+            body = json.loads(exc.read() or b"null")
+        except ValueError:
+            body = None
+        return exc.code, body
+    except (urllib.error.URLError, OSError, ValueError):
+        return 0, None
+
+
+def ready(port: int) -> bool:
+    status, body = get_json(port, "/health/ready")
+    return status == 200 and isinstance(body, dict) and body.get("status") == "ready"
+
+
+def wait_until(
+    check: Callable[[], bool],
+    *,
+    timeout: float,
+    interval: float = 1.0,
+    should_stop: Callable[[], bool] = lambda: False,
+    sleep: Callable[[float], None] = time.sleep,
+    clock: Callable[[], float] = time.monotonic,
+) -> bool:
+    """Poll ``check`` until it is true (True), ``should_stop`` is true or time runs out (False)."""
+    deadline = clock() + timeout
+    while True:
+        if check():
+            return True
+        if should_stop() or clock() >= deadline:
+            return False
+        sleep(interval)

modelmux_cli/main.py

@@ -0,0 +1,119 @@
+"""``modelmux``: set up, log in to and run ModelMux.
+
+This module only parses arguments and reports errors. Each command lives in
+``modelmux_cli.commands``; the commands that are not built yet say so.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import traceback
+from collections.abc import Callable, Sequence
+
+from modelmux_cli import __version__
+from modelmux_cli.clientconfig import TARGETS
+from modelmux_cli.commands import basic, config_cmd
+from modelmux_cli.commands import doctor as doctor_command
+from modelmux_cli.commands import login as login_command
+from modelmux_cli.commands import logout as logout_command
+from modelmux_cli.commands import up as up_command
+from modelmux_cli.commands import upgrade as upgrade_command
+from modelmux_cli.console import Console
+from modelmux_cli.errors import EXIT_FAILURE, EXIT_INTERRUPTED, CliError
+from modelmux_cli.providers import load_providers
+
+Handler = Callable[[argparse.Namespace, Console], int]
+
+
+def build_parser() -> argparse.ArgumentParser:
+    providers = sorted(load_providers())
+    parser = argparse.ArgumentParser(
+        prog="modelmux",
+        description="Run AI coding CLIs as a secure, OpenAI-compatible API.",
+        epilog="Start with: modelmux up, then modelmux login <provider>.",
+    )
+    parser.add_argument("--version", action="version", version=f"modelmux {__version__}")
+    parser.add_argument("-v", "--verbose", action="store_true", help="show details and commands")
+    parser.add_argument("--no-color", action="store_true", help="disable coloured output")
+    sub = parser.add_subparsers(dest="command", metavar="<command>", required=True)
+
+    up = sub.add_parser("up", help="start ModelMux (logged-in providers)")
+    up.add_argument(
+        "providers", nargs="*", metavar="provider", help=f"any of: {', '.join(providers)}"
+    )
+    up.add_argument("--image", metavar="REF", help="server image to run (remembered)")
+    up.add_argument(
+        "--port", action="append", metavar="PROVIDER=PORT", help="local port (remembered)"
+    )
+    up.set_defaults(handler=up_command.run)
+
+    down = sub.add_parser("down", help="stop ModelMux (logins are kept)")
+    down.set_defaults(handler=basic.down)
+
+    logs = sub.add_parser("logs", help="show server logs")
+    logs.add_argument("provider", nargs="?", choices=providers)
+    logs.add_argument("-f", "--follow", action="store_true", help="keep streaming new lines")
+    logs.add_argument("--tail", type=int, default=100, metavar="N", help="lines to show (100)")
+    logs.set_defaults(handler=basic.logs)
+
+    status = sub.add_parser("status", help="what is running, logged in and healthy")
+    status.set_defaults(handler=basic.status)
+
+    login = sub.add_parser("login", help="log a provider in (guided)")
+    login.add_argument("provider", choices=providers)
+    login.add_argument("--method", help="login method (see the provider's options)")
+    login.add_argument("--no-browser", action="store_true", help="do not open a browser")
+    login.add_argument("--raw", action="store_true", help="show the provider's raw output")
+    login.add_argument("--force", action="store_true", help="log in again even if logged in")
+    login.set_defaults(handler=login_command.run)
+
+    logout = sub.add_parser("logout", help="remove a provider's saved login")
+    logout.add_argument("provider", choices=providers)
+    logout.add_argument("-y", "--yes", action="store_true", help="do not ask for confirmation")
+    logout.set_defaults(handler=logout_command.run)
+
+    config = sub.add_parser("config", help="print ready-to-paste client config")
+    config.add_argument("target", choices=TARGETS)
+    config.add_argument("--provider", choices=providers)
+    config.add_argument("--reveal-key", action="store_true", help="include the real API key")
+    config.set_defaults(handler=config_cmd.config)
+
+    doctor = sub.add_parser("doctor", help="diagnose common problems")
+    doctor.set_defaults(handler=doctor_command.run)
+
+    upgrade = sub.add_parser("upgrade", help="run the image matching this CLI version")
+    upgrade.add_argument("--image", metavar="REF", help="use a different image (advanced)")
+    upgrade.set_defaults(handler=upgrade_command.run)
+
+    key = sub.add_parser("key", help="the API key clients use to call ModelMux")
+    key_sub = key.add_subparsers(dest="key_command", metavar="<action>", required=True)
+    key_show = key_sub.add_parser("show", help="print the API key")
+    key_show.set_defaults(handler=config_cmd.key_show)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    raw = list(sys.argv[1:] if argv is None else argv)
+    # Until arguments are parsed, honour --verbose from the raw command line.
+    console = Console(verbose="-v" in raw or "--verbose" in raw)
+    try:
+        parser = build_parser()
+        args = parser.parse_args(raw)
+        console = Console(verbose=args.verbose, color=False if args.no_color else None)
+        handler: Handler = args.handler
+        return handler(args, console)
+    except CliError as exc:
+        console.error(exc.message, exc.hint)
+        return exc.exit_code
+    except KeyboardInterrupt:
+        console.error("Cancelled.")
+        return EXIT_INTERRUPTED
+    except Exception:
+        console.error(
+            "Something unexpected went wrong.",
+            "Run again with --verbose for details, and please report it if it keeps happening.",
+        )
+        if console.verbose:
+            console.detail(traceback.format_exc())
+        return EXIT_FAILURE

modelmux_cli/paths.py

@@ -0,0 +1,51 @@
+"""Where the CLI keeps its own files.
+
+| OS      | Directory                                          |
+|---------|----------------------------------------------------|
+| Linux   | ``$XDG_CONFIG_HOME/modelmux`` (``~/.config/modelmux``) |
+| macOS   | ``~/Library/Application Support/modelmux``         |
+| Windows | ``%APPDATA%\\modelmux``                             |
+
+``MODELMUX_CLI_HOME`` overrides it (tests, portable setups). The directory
+holds only small files: ``config.json``, ``secrets.env`` (mode 0600) and the
+generated ``compose.yaml``. Logins never live here: they stay in Docker
+volumes.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Mapping
+from pathlib import Path, PurePosixPath
+
+APP_NAME = "modelmux"
+OVERRIDE_ENV = "MODELMUX_CLI_HOME"
+
+
+def config_dir(
+    env: Mapping[str, str] | None = None,
+    platform: str | None = None,
+    home: Path | None = None,
+) -> Path:
+    env = os.environ if env is None else env
+    platform = platform or sys.platform
+    if override := env.get(OVERRIDE_ENV):
+        return Path(override).expanduser()
+    home = home or Path.home()
+    if platform == "win32":
+        base = Path(env["APPDATA"]) if env.get("APPDATA") else home / "AppData" / "Roaming"
+    elif platform == "darwin":
+        base = home / "Library" / "Application Support"
+    else:
+        xdg = env.get("XDG_CONFIG_HOME")
+        base = Path(xdg) if xdg and PurePosixPath(xdg).is_absolute() else home / ".config"
+    return base / APP_NAME
+
+
+def ensure_private_dir(path: Path) -> Path:
+    """Create ``path`` if needed; on POSIX make it accessible to the owner only."""
+    path.mkdir(parents=True, exist_ok=True)
+    if os.name == "posix":
+        path.chmod(0o700)
+    return path

modelmux_cli/ports.py

@@ -0,0 +1,29 @@
+"""Is a local port free? (Checked with a socket bind: no extra processes.)"""
+
+from __future__ import annotations
+
+import socket
+import sys
+
+from modelmux_cli.health import LOCALHOST
+
+
+def port_free(port: int, host: str = LOCALHOST) -> bool:
+    """True unless another program is listening on ``host:port``.
+
+    Ports in TIME_WAIT (for example right after ``modelmux down``) count as
+    free, as they do for Docker: on POSIX ``SO_REUSEADDR`` ignores TIME_WAIT
+    but still fails against a live listener. On Windows ``SO_REUSEADDR`` would
+    allow stealing a port, so ``SO_EXCLUSIVEADDRUSE`` is used instead.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        if sys.platform == "win32":
+            exclusive = getattr(socket, "SO_EXCLUSIVEADDRUSE")  # noqa: B009 - Windows-only name
+            sock.setsockopt(socket.SOL_SOCKET, exclusive, 1)
+        else:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            sock.bind((host, port))
+        except OSError:
+            return False
+    return True