Add Gitea Actions CI: test + build/push to registry

Matches the pattern used by Dashboard and Zbrane-Reiner-Web -- release
branch pushes :latest, devel pushes :devel. Requires a REGISTRY_TOKEN
secret on this repo (Settings -> Actions -> Secrets), same as those two.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WDDfSVPh5pgNe7TRpZUgJA

.gitea/workflows/ci.yml

@@ -8,7 +8,7 @@ on:
 
 jobs:
   test:
-    runs-on: amd64
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
 
@@ -31,15 +31,9 @@ jobs:
       - name: Testy
         run: poetry run pytest -q
 
-  # Každá architektura se staví NATIVNĚ na vlastním runneru (label = architektura):
+  build-and-push:
-  #   amd64 -> srv2-amd64-runner (SRV2), arm64 -> srv1-arm64-runner (SRV1, RPi 4).
-  # Žádná emulace (QEMU). Každý běh pushne image s příponou architektury.
-  build:
     needs: test
-    strategy:
+    runs-on: ubuntu-latest
-      matrix:
-        arch: [amd64, arm64]
-    runs-on: ${{ matrix.arch }}
     steps:
       - uses: actions/checkout@v4
 
@@ -63,44 +57,10 @@ jobs:
           echo '${{ secrets.REGISTRY_TOKEN }}' \
             | docker login gitea.doubynet.eu -u '${{ github.actor }}' --password-stdin
 
-      # --provenance=false: bez atestace je per-arch tag obyčejný obrázek. S ní by to byl
+      - name: Build image
-      # index (obrázek + atestace) a `docker manifest create` index do indexu nespojí.
+        run: docker build -t "$IMAGE:$MOVING_TAG" -t "$IMAGE:${{ github.sha }}" .
-      - name: Build image (${{ matrix.arch }})
-        run: |
-          docker build --provenance=false \
-            -t "$IMAGE:$MOVING_TAG-${{ matrix.arch }}" \
-            -t "$IMAGE:${{ github.sha }}-${{ matrix.arch }}" .
 
-      - name: Push image (${{ matrix.arch }})
+      - name: Push image
         run: |
-          docker push "$IMAGE:$MOVING_TAG-${{ matrix.arch }}"
+          docker push "$IMAGE:$MOVING_TAG"
-          docker push "$IMAGE:${{ github.sha }}-${{ matrix.arch }}"
+          docker push "$IMAGE:${{ github.sha }}"
-
-  # Spojí obě architektury pod jedno jméno tagu. `docker pull ...:devel` pak na
-  # amd64 i arm64 stroji sám vybere správnou variantu.
-  manifest:
-    needs: build
-    runs-on: amd64
-    steps:
-      - name: Název image a značka
-        run: |
-          echo "IMAGE=gitea.doubynet.eu/$(echo '${{ github.repository }}' \
-            | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_ENV"
-          if [ "${{ github.ref_name }}" = "release" ]; then
-            echo "MOVING_TAG=latest" >> "$GITHUB_ENV"
-          else
-            echo "MOVING_TAG=devel" >> "$GITHUB_ENV"
-          fi
-
-      - name: Přihlášení do Gitea registry
-        run: |
-          echo '${{ secrets.REGISTRY_TOKEN }}' \
-            | docker login gitea.doubynet.eu -u '${{ github.actor }}' --password-stdin
-
-      - name: Multi-arch manifest (moving tag + commit SHA)
-        run: |
-          for TAG in "$MOVING_TAG" "${{ github.sha }}"; do
-            docker manifest create --amend "$IMAGE:$TAG" \
-              "$IMAGE:$TAG-amd64" "$IMAGE:$TAG-arm64"
-            docker manifest push "$IMAGE:$TAG"
-          done

AGENTS.md

@@ -1,21 +1,24 @@
 # AI Agents - Project Rules
 
-**Document Version:** v9 (independent, incremented on structural changes)
+**Document Version:** v8 (independent, incremented on structural changes)
 
 Language-agnostic rules for AI assistants (Claude Code, Cursor, Copilot, etc.).
 
-Everything specific — package manager, formatter, linter, test framework, logging library,
+Everything language-specific — package manager, formatter, linter, test framework,
-line length, project layout, interface conventions — lives in the design documents.
+logging library, line length, project layout — lives in the matching design document:
 
-**Find them, do not look them up in a list:** every file matching `DESIGN_DOCUMENT*.md` in the
+| Project type       | Design document                    |
-project root applies to this project. The suffix says what it covers — the language
+|--------------------|------------------------------------|
-(`DESIGN_DOCUMENT_PYTHON.md`), whether it is an application or a library
+| Python application | `DESIGN_DOCUMENT_PYTHON.md`        |
-(`..._PYTHON_MODULE.md`), or a part of the system that has conventions of its own
+| Python library     | `DESIGN_DOCUMENT_PYTHON_MODULE.md` |
-(`..._WEBAPP.md`). A project carries as many as it needs and nothing collides, so no list here
+| Rust application   | `DESIGN_DOCUMENT_RUST.md`          |
-needs maintaining and none can go stale.
+| Rust library       | `DESIGN_DOCUMENT_RUST_LIB.md`      |
+| Godot              | `DESIGN_DOCUMENT_GODOT.md`         |
 
-Where this file and a design document disagree, **the design document wins**. Where two design
+The language is part of the file name, so a project that mixes languages carries one design document
-documents disagree, the more specific one wins for what it covers.
+per language and nothing collides.
+
+Where this file and a design document disagree, **the design document wins**.
 
 ## First-time setup
 

CHANGELOG.md

@@ -12,18 +12,11 @@ All notable changes to this project are documented in this file.
   and per-channel MPEG-TS streams for Jellyfin Live TV.
 - Docker Compose deployment (`Dockerfile`, `docker-compose.yml`) and configuration templates
   (`channels.example.yaml`, `.env.example`).
-- Gitea Actions CI (`.gitea/workflows/ci.yml`): ruff, mypy and pytest, then native `amd64` and `arm64` image builds on
-  separate runners (no emulation), merged into one multi-arch tag (`:devel` from `devel`, `:latest` from `release`,
-  plus a commit-SHA tag). Per-architecture tags carry an `-amd64` / `-arm64` suffix.
 - Unit test suite covering config parsing, URL expiry parsing, ffmpeg argument building, playlist generation, and
   broadcast fan-out.
 
 ### Fixed
 
-- Stopping ffmpeg (on every proactive URL refresh) no longer stalls. The worker stops reading ffmpeg's stdout when it
-  breaks out to refresh, and asyncio's `Process.wait()` does not return until every pipe reaches EOF, so `stop()` always
-  ran into the terminate timeout ("did not exit in time, killing it") and could leave a channel worker stuck for good,
-  silently ending that channel's stream. `stop()` now drains the leftover stdout while waiting for ffmpeg to exit.
 - `/stream/{channel_id}` now forces the connection closed after each response (`Connection: close`) instead of
   allowing keep-alive. Jellyfin's M3U tuner client (`SharedHttpStream`) was reusing a pooled keep-alive connection
   still mid-stream from an earlier request and reading raw MPEG-TS bytes as if they were a fresh HTTP response,

PROJECT.md

@@ -14,8 +14,6 @@ Initial implementation in place:
   aiohttp server (`/playlist.m3u`, `/stream/{channel_id}`, `/healthz`), config loading.
 - `serve.py` — entry point.
 - `Dockerfile` / `docker-compose.yml` — containerized deployment.
-- `.gitea/workflows/ci.yml` — CI: tests, then native `amd64` + `arm64` builds (one runner per architecture) merged
-  into a single multi-arch image in the Gitea registry.
 - `channels.example.yaml`, `.env.example` — configuration templates.
 - Unit tests for the pure/testable pieces (config parsing, URL expiry parsing, ffmpeg argument building, playlist
   generation, broadcast fan-out).

src/restreamer/ffmpeg_runner.py

@@ -74,10 +74,6 @@ class FfmpegStreamProcess:
         if self._process is None or self._process.returncode is not None:
             return
 
-        # wait() only returns once every pipe hits EOF, so unread stdout left over
-        # from the consumer breaking out of iter_chunks() must be drained, or it hangs forever.
-        stdout_drain_task = asyncio.create_task(self._drain_stdout())
-
         self._process.terminate()
         try:
             await asyncio.wait_for(self._process.wait(), timeout=FFMPEG_TERMINATE_TIMEOUT_SECONDS)
@@ -86,16 +82,9 @@ class FfmpegStreamProcess:
             self._process.kill()
             await self._process.wait()
 
-        await stdout_drain_task
         if self._stderr_task is not None:
             await self._stderr_task
 
-    async def _drain_stdout(self) -> None:
-        if self._process is None or self._process.stdout is None:
-            return
-        while await self._process.stdout.read(FFMPEG_READ_CHUNK_SIZE):
-            pass
-
     async def _drain_stderr(self) -> None:
         if self._process is None or self._process.stderr is None:
             return

tests/test_ffmpeg_runner.py

@@ -1,10 +1,4 @@
-import asyncio
+from restreamer.ffmpeg_runner import build_ffmpeg_args
-
-import pytest
-
-from restreamer import ffmpeg_runner
-from restreamer.constants import FFMPEG_TERMINATE_TIMEOUT_SECONDS
-from restreamer.ffmpeg_runner import FfmpegStreamProcess, build_ffmpeg_args
 from restreamer.resolver import ResolvedStream
 
 
@@ -48,15 +42,3 @@ def test_build_ffmpeg_args_maps_separate_video_and_audio_inputs() -> None:
     assert "-map" in args
     map_values = [args[i + 1] for i, a in enumerate(args) if a == "-map"]
     assert map_values == ["0:v:0", "1:a:0"]
-
-
-async def test_stop_returns_when_consumer_left_stdout_unread(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(ffmpeg_runner, "build_ffmpeg_args", lambda stream: ["yes"])
-    process = FfmpegStreamProcess(ResolvedStream(video_url="https://example.com/stream.m3u8"), "test")
-    await process.start()
-    async for _chunk in process.iter_chunks():
-        break
-
-    await asyncio.wait_for(process.stop(), timeout=FFMPEG_TERMINATE_TIMEOUT_SECONDS / 2)
-
-    assert await process.wait() != 0