commitrocket 0.1.1__py3-none-any.whl

commitrocket/push.py

@@ -0,0 +1,246 @@
+import logging
+import os
+import re
+import subprocess
+import time
+
+from rich.markup import escape
+
+from commitrocket.errors import PushError
+from commitrocket.security import redact
+
+logger = logging.getLogger(__name__)
+
+PERCENT_RE = re.compile(r"(\d{1,3})%")
+
+UPLOAD_PHASE = "Uploading objects"
+LFS_PHASE = "Uploading LFS objects"
+
+# git-lfs reports e.g. "Uploading LFS objects:  50% (1/2), 52 MB | 3.2 MB/s".
+# The percentage counts files, so the transferred byte count is used instead.
+LFS_BYTES_RE = re.compile(
+    r"Uploading LFS objects:.*?\)\s*,\s*([\d.]+)\s*([KMGT]?B)\b", re.IGNORECASE
+)
+LFS_UNITS = {"B": 1, "KB": 1000, "MB": 1000**2, "GB": 1000**3, "TB": 1000**4}
+
+# Output that means the host refused the push, so a retry would fail the same way.
+NON_RETRYABLE_MARKERS = (
+    "[rejected]",
+    "[remote rejected]",
+    "remote rejected",
+    "pre-receive hook declined",
+    "non-fast-forward",
+    "fetch first",
+    "gh001",
+    "large files detected",
+    "protected branch",
+    "authentication failed",
+    "permission denied",
+    "access denied",
+    "repository not found",
+    "could not read username",
+)
+
+RETRY_BASE_SECONDS = 5
+
+PHASES = (
+    ("enumerating objects", "Enumerating objects"),
+    ("counting objects", "Counting objects"),
+    ("compressing objects", "Compressing objects"),
+    ("writing objects", UPLOAD_PHASE),
+    ("resolving deltas", "Resolving deltas"),
+    ("receiving objects", "Receiving objects"),
+)
+
+
+def parse_progress_line(line):
+    """Return (phase, percent) for a git progress line; percent may be None."""
+    match = PERCENT_RE.search(line)
+    percent = min(100, int(match.group(1))) if match else None
+
+    lower = line.lower()
+    phase = next((label for key, label in PHASES if key in lower), "Git push")
+    return phase, percent
+
+
+def is_retryable(output):
+    """False for failures that trying again cannot fix (rejections, auth)."""
+    lower = output.lower()
+    return not any(marker in lower for marker in NON_RETRYABLE_MARKERS)
+
+
+def parse_lfs_bytes(line):
+    """Bytes transferred so far according to a git-lfs upload line, else None."""
+    match = LFS_BYTES_RE.search(line)
+    if not match:
+        return None
+    return int(float(match.group(1)) * LFS_UNITS[match.group(2).upper()])
+
+
+def push_with_retries(
+    repo, progress, push_task, console, retries=0, sleep=time.sleep, **kwargs
+):
+    """push_with_progress, retried with growing waits on transient errors."""
+    attempt = 0
+    while True:
+        try:
+            return push_with_progress(repo, progress, push_task, console, **kwargs)
+        except PushError as exc:
+            if not exc.retryable or attempt >= retries:
+                raise
+
+            delay = RETRY_BASE_SECONDS * 3**attempt
+            attempt += 1
+            logger.warning(
+                "Push failed (attempt %d of %d), retrying in %d s: %s",
+                attempt,
+                retries,
+                delay,
+                exc,
+            )
+            console.print(
+                f"[yellow]Push failed. Retrying in {delay} s "
+                f"(retry {attempt} of {retries})...[/yellow]"
+            )
+            sleep(delay)
+
+
+def push_with_progress(
+    repo,
+    progress,
+    push_task,
+    console,
+    on_upload=None,
+    batch_bytes=None,
+    remote=None,
+    refspec=None,
+):
+    """Stream Git push progress into a live Rich progress task.
+
+    on_upload, if given, is called with a rising percent (0-100) of the upload,
+    covering both the git-lfs upload and the pack transfer. batch_bytes is the
+    size of the batch being pushed and lets LFS byte counts become a percent.
+    """
+    console.print("\n[bold cyan]Pushing commit...[/bold cyan]")
+    logger.info("Pushing %s", repo)
+
+    progress.update(
+        push_task,
+        description="Git push: Starting",
+        total=100,
+        completed=0,
+        visible=True,
+    )
+
+    process = subprocess.Popen(
+        ["git", "-C", str(repo), "push", "--progress"]
+        + (["--", remote, refspec] if remote else []),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        bufsize=0,
+        # Without a terminal git-lfs would otherwise print no progress at all.
+        env={**os.environ, "GIT_LFS_FORCE_PROGRESS": "1"},
+    )
+
+    pending = b""
+    messages = []
+    best_percent = 0
+    logged_phase = None
+
+    try:
+        while True:
+            chunk = os.read(process.stdout.fileno(), 4096)
+
+            if not chunk:
+                break
+
+            pending += chunk
+
+            # Git progress commonly uses carriage returns instead
+            # of newlines to refresh terminal output.
+            parts = re.split(rb"[\r\n]+", pending)
+            pending = parts.pop()
+
+            for raw_line in parts:
+                line = raw_line.decode("utf-8", errors="replace").strip()
+
+                if not line:
+                    continue
+
+                messages.append(line)
+
+                phase, percent = parse_progress_line(line)
+
+                uploaded = parse_lfs_bytes(line)
+                if uploaded is not None:
+                    phase = LFS_PHASE
+                    if batch_bytes:
+                        percent = min(100, int(uploaded * 100 / batch_bytes))
+
+                # Progress lines repeat constantly; keep one per phase change
+                # plus the final one, and every other line.
+                if percent is None or phase != logged_phase or percent == 100:
+                    logger.debug("push: %s", line)
+                    logged_phase = phase
+
+                if (
+                    on_upload
+                    and percent is not None
+                    and phase in (UPLOAD_PHASE, LFS_PHASE)
+                    and percent > best_percent
+                ):
+                    best_percent = percent
+                    on_upload(percent)
+
+                if percent is not None:
+                    progress.update(
+                        push_task,
+                        description=phase,
+                        completed=percent,
+                        total=100,
+                        visible=True,
+                    )
+                else:
+                    progress.update(push_task, description=phase, visible=True)
+
+        # Process any final output without a trailing delimiter.
+        if pending.strip():
+            line = pending.decode("utf-8", errors="replace").strip()
+            if line:
+                messages.append(line)
+
+        return_code = process.wait()
+
+    except BaseException:
+        process.kill()
+        process.wait()
+        raise
+
+    finally:
+        if process.stdout:
+            process.stdout.close()
+
+    logger.info("git push finished with exit code %d", return_code)
+
+    if return_code != 0:
+        progress.update(push_task, description="Git push failed", visible=True)
+        raise PushError(
+            "git push failed with exit code "
+            f"{return_code}:\n" + redact("\n".join(messages[-15:])),
+            retryable=is_retryable("\n".join(messages)),
+        )
+
+    progress.update(
+        push_task,
+        description="Git push complete",
+        completed=100,
+        total=100,
+        visible=True,
+    )
+
+    # Display non-progress messages such as the remote branch update.
+    for line in messages:
+        if not PERCENT_RE.search(line):
+            console.print(f"[dim]{escape(redact(line))}[/dim]")
+
+    progress.update(push_task, visible=False)

commitrocket/report.py

@@ -0,0 +1,130 @@
+import json
+import os
+import tempfile
+import time
+from dataclasses import asdict
+from datetime import UTC, datetime
+from pathlib import Path
+
+from commitrocket import __version__
+from commitrocket.security import redact_value, restrict_permissions
+
+SCHEMA_VERSION = 1
+
+SUCCESS = "success"
+DEFERRED = "completed_with_deferred_files"
+DRY_RUN = "dry_run"
+CANCELLED = "cancelled"
+ABORTED = "aborted"
+INTERRUPTED = "interrupted"
+FAILED = "failed"
+
+
+class RunReport:
+    """Collects what a run did, for --report and for notifications."""
+
+    def __init__(self, options=None):
+        self.started_at = datetime.now(UTC)
+        self._started = time.monotonic()
+        self.finished_at = None
+        self.duration_seconds = None
+        self.status = FAILED
+        self.exit_code = None
+        self.error = None
+        self.repo = None
+        self.branch = None
+        self.target = None
+        self.log_file = None
+        # --remote may be a URL with embedded credentials.
+        self.settings = redact_value(asdict(options)) if options else {}
+        self.resumed = {"staged_files": 0, "unpushed_commits": 0}
+        self.lfs = {"files": 0, "rules_commit": None}
+        self.batches = []
+        self.deferred = []
+
+    def abort(self, reason):
+        self.status = ABORTED
+        self.error = reason
+
+    def add_batch(self, number, message, files, size_bytes, lfs_files=0, commit=None):
+        entry = {
+            "number": number,
+            "message": message,
+            "commit": commit,
+            "file_count": len(files),
+            "size_bytes": size_bytes,
+            "lfs_file_count": lfs_files,
+            "pushed": False,
+            "verified": False,
+            "files": list(files),
+        }
+        self.batches.append(entry)
+        return entry
+
+    def set_deferred(self, items):
+        self.deferred = [{"path": path, "size_bytes": size} for path, size in items]
+
+    def finish(self, exit_code, log_file=None):
+        self.exit_code = exit_code
+        self.log_file = str(log_file) if log_file else None
+        self.finished_at = datetime.now(UTC)
+        self.duration_seconds = round(time.monotonic() - self._started, 3)
+
+    @property
+    def total_files(self):
+        return sum(batch["file_count"] for batch in self.batches)
+
+    @property
+    def total_bytes(self):
+        return sum(batch["size_bytes"] for batch in self.batches)
+
+    def to_dict(self):
+        return {
+            "schema_version": SCHEMA_VERSION,
+            "tool": "commitrocket",
+            "version": __version__,
+            "status": self.status,
+            "exit_code": self.exit_code,
+            "error": self.error,
+            "started_at": self.started_at.isoformat(),
+            "finished_at": self.finished_at.isoformat() if self.finished_at else None,
+            "duration_seconds": self.duration_seconds,
+            "repo": self.repo,
+            "branch": self.branch,
+            "target": self.target,
+            "dry_run": bool(self.settings.get("dry_run")),
+            "no_push": bool(self.settings.get("no_push")),
+            "settings": self.settings,
+            "resumed": self.resumed,
+            "lfs": self.lfs,
+            "totals": {
+                "batches": len(self.batches),
+                "files": self.total_files,
+                "size_bytes": self.total_bytes,
+                "deferred_files": len(self.deferred),
+            },
+            "batches": self.batches,
+            "deferred": self.deferred,
+            "log_file": self.log_file,
+        }
+
+    def write(self, path):
+        """Write the report as JSON, replacing any file there in one step."""
+        path = Path(path).expanduser()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        text = json.dumps(self.to_dict(), indent=2, ensure_ascii=False) + "\n"
+
+        # A randomly named file created exclusively (and private to the owner), so
+        # nobody can pre-create a link at a predictable name to redirect the write.
+        descriptor, name = tempfile.mkstemp(
+            dir=path.parent, prefix=path.name + ".", suffix=".tmp"
+        )
+        try:
+            with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+                handle.write(text)
+            restrict_permissions(name)
+            os.replace(name, path)
+        except BaseException:
+            Path(name).unlink(missing_ok=True)
+            raise
+        return path.resolve()