feat(dispatcharr): update image docker.io/dispatcharr/dispatcharr 0.26.0 → 0.27.0 (#49205)

This PR contains the following updates:

| Package | Update | Change |
|---|---|---|
|
[docker.io/dispatcharr/dispatcharr](https://redirect.github.com/Dispatcharr/Dispatcharr)
| minor | `9275b0c` → `4251290` |

---

> [!WARNING]
> Some dependencies could not be looked up. Check the [Dependency
Dashboard](../issues/18710) for more information.

Add the preset `:preserveSemverRanges` to your config if you don't want
to pin your dependencies.

---

### Release Notes

<details>
<summary>Dispatcharr/Dispatcharr
(docker.io/dispatcharr/dispatcharr)</summary>

###
[`v0.27.0`](https://redirect.github.com/Dispatcharr/Dispatcharr/blob/HEAD/CHANGELOG.md#0270---2026-06-16)

[Compare
Source](https://redirect.github.com/Dispatcharr/Dispatcharr/compare/v0.26.0...v0.27.0)

##### Added

- **Manual Server Groups for shared M3U connection limits.** The
existing `ServerGroup` model and account FK are now wired into live and
VOD playback. Accounts assigned to the same group share a
credential-scoped Redis counter when their provider logins match (hashed
fingerprint); unrelated logins in the same group keep separate counters.
Enforcement uses each profile's `max_streams` - not a group-wide cap -
and profiles with `max_streams=0` skip credential pooling for that
profile while still rotating on their own per-profile counter. New
`apps/m3u/connection_pool.py` centralizes reserve/release, profile
rotation, and credential moves on profile switch. (Closes
[#&#8203;1137](https://redirect.github.com/Dispatcharr/Dispatcharr/issues/1137))
— Thanks
[@&#8203;Goldenfreddy0703](https://redirect.github.com/Goldenfreddy0703)
- **Server Groups manager UI** on the M3U Accounts page: create, rename,
and delete groups with account counts and delete confirmation. Groups
load on login via a new Zustand store and REST helpers
(`/api/m3u/server-groups/`).
- **M3U account form** adds a Server Group picker (including inline “add
group”), reorganized into three columns (source/auth, connection limits,
sync/content), and a Manage server groups shortcut.
- **VOD profile selection** uses `pool_has_capacity_for_profile()` so
grouped accounts respect shared credential limits before a profile is
chosen (non-grouped accounts behave as before).
- **Live profile switches** move the shared credential counter when the
new profile uses a different provider login; same-login switches leave
the credential counter unchanged.
- **Credential release keys** stored at reserve time allow counters to
be released even if the M3U profile row is deleted afterward.
- **PostgreSQL `application_name` tagging by process role.** Pool
connections now set `application_name` at connect time (e.g.
`Dispatcharr-uwsgi-{pid}`, `Dispatcharr-celery-worker-{pid}`,
`Dispatcharr-celery-dvr-{pid}`) so `pg_stat_activity` shows which
Dispatcharr process owns each backend instead of a generic client label.

##### Changed

- **Plugin repo manifests support split download and metadata base
URLs.** `download_base_url` and `metadata_base_url` are optional
alternatives to `root_url` in the plugin repository manifest, so repo
authors can serve metadata (manifests, icons) and release zips from
different origins without absolute URLs everywhere. Manifest and icon
URLs resolve via `metadata_base_url` then `root_url`; latest/download
URLs resolve via `download_base_url` then `root_url`. When
`metadata_base_url` is set and a plugin entry has `manifest_url` but no
`icon_url`, the icon defaults to `logo.png` in the same directory as the
per-plugin manifest. Manifests using only `root_url` behave identically
to before. — Thanks [@&#8203;sethwv](https://redirect.github.com/sethwv)
- **Live and VOD connection slot logic now routes through
`connection_pool`.** `Channel.get_stream()`, direct
`Stream.get_stream()`, VOD profile selection, and the multi-worker VOD
connection manager all call `reserve_profile_slot()` /
`release_profile_slot()` instead of inline Redis INCR/DECR. VOD profile
selection also checks `pool_has_capacity_for_profile()` before choosing
a profile.
- **Live XC upstream URLs use current credentials.**
`_resolve_live_stream_url()` builds `/live/{user}/{pass}/{stream_id}.ts`
from transformed account credentials and the stream's provider
`stream_id`, so playback stays aligned with the active login after
credential or profile changes instead of reusing a stale `stream.url`
from sync.
- **Channel stream switches check pooled capacity.**
`get_stream_info_for_switch()` uses
`profile_available_for_channel_switch()` when targeting a specific
stream, and releases a reserved slot if URL assembly fails after
`get_stream()` allocated one.
- **Live proxy init reads Redis assignment once.** After
`generate_stream_url()` reserves a slot, the stream handler reads
`channel_stream` / `stream_profile` from Redis instead of calling
`get_stream()` again, avoiding double INCR under concurrent release.
- **Centralized Dispatcharr User-Agent construction in `core.utils`.**
Outbound HTTP calls (Schedules Direct API, update checks, logo/VOD
fallbacks, DVR recording clients) now use `dispatcharr_user_agent()`,
`dispatcharr_dvr_user_agent()`, and `dispatcharr_http_headers()` instead
of ad-hoc `Dispatcharr/{version}` strings and stale `Dispatcharr/1.0`
fallbacks.
- **EPG auto-match overhaul** — matching logic moved to
`apps/channels/epg_matching.py`; Celery tasks in `tasks.py` are thin
wrappers.
- Single-channel auto-match is now asynchronous: the API returns `202
Accepted` and pushes the result over WebSocket
(`single_channel_epg_match`), so large EPG libraries no longer hit the
previous 30-second HTTP timeout.
- Progress, bulk completion, and single-channel results use
`send_websocket_update` instead of
`async_to_sync(channel_layer.group_send)`, so notifications work
reliably under gevent-patched uWSGI and Celery workers.
- Single-channel and selected-channel auto-match always run, even when
the channel already has EPG assigned; match-all (no channel IDs) still
only processes channels without EPG.
- Rematching to the same EPG no longer re-saves the channel or queues
program-parse tasks; only assignments that actually change are written
and refreshed.
- **Easier EPG search when editing a channel.** The filter in the EPG
picker now works more like a normal search box. You can type several
words at once (e.g. `sky uk`) and it finds channels where every word
appears somewhere in the name or TVG-ID, the order doesn't matter, and a
word in the name can pair with one in the ID. Accents are ignored too,
so `decale` matches `Décalé` and the other way around. — Thanks
[@&#8203;FiveBoroughs](https://redirect.github.com/FiveBoroughs)

##### Performance

- **XC live refresh releases bulk catalog data sooner during batch
processing.** After filtering the single `get_all_live_streams`
response, the full provider catalog list is dropped before batch DB
work. `process_m3u_batch_direct` (the path XC refreshes use) now runs
`gc.collect()` after each batch and clears batch slice references as
thread futures complete. Large structures are still `del`'d in the
refresh `finally` block before Celery's `task_postrun` runs
`cleanup_memory()`.
- **VOD movie/series batch matching no longer scans the full no-ID
catalog.** `process_movie_batch` and `process_series_batch` previously
loaded every `Movie`/`Series` row without TMDB or IMDB IDs on each
1000-item chunk to resolve name+year duplicates. Lookup is now scoped to
the names in the current batch via `lookup_by_name_year()`, which
reduces memory and DB time per chunk. `refresh_vod_content` and
`batch_refresh_series_episodes` are registered for Celery post-task
memory cleanup (one GC pass at task end, not per chunk).
- **EPG programme parse now streams through PostgreSQL staging instead
of holding the full catalogue in Python.** `parse_programs_for_source`
writes parsed rows into a session-scoped temp table in batches
(`_EPG_PARSE_BATCH_SIZE=2500`), then atomically swaps them into
`ProgramData` with batched `DELETE ... RETURNING` + `INSERT`
(`_EPG_SWAP_BATCH_SIZE=5000`) so Postgres never materializes the entire
guide in one statement. Peak Celery memory during large XMLTV refreshes
drops sharply compared with building a monolithic in-memory list before
bulk insert. The byte-offset programme index build is deferred until
after the swap completes so index construction no longer competes with
parse for memory and I/O. `refresh_epg_data` closes its DB connection in
`finally`, and `build_programme_index_task` is registered as a
memory-intensive Celery task. SQLite/dev installs keep an in-memory
fallback path.
- **Pooled PostgreSQL connections now rotate on a bounded lifetime.**
psycopg3 client-side cache grows on handles kept open indefinitely by
`django-db-geventpool`; recycling uWSGI workers would interrupt live
streams. A thin custom backend
(`dispatcharr.db.backends.postgresql_psycopg3`) closes and replaces pool
connections after `DATABASE_POOL_CONN_MAX_LIFETIME` seconds (default
600, env-overridable; set `0` to disable) on checkout and return while
preserving warm-pool reuse within the window. (Fixes
[#&#8203;1343](https://redirect.github.com/Dispatcharr/Dispatcharr/issues/1343))
- **Schedules Direct refresh only fetches guide data for mapped
channels.** Schedule MD5 checks and schedule downloads now target mapped
lineup stations instead of the entire lineup, and schedule MD5 cache for
unmapped stations is pruned each refresh. Unmapped lineup entries no
longer trigger wasted schedule API calls when their MD5 changes.
- **EPG auto-match memory and throughput improvements.**
- Single-channel matching streams active EPG rows and keeps only the
best match plus the top 20 candidates in memory; ML validates at most 21
names per channel instead of embedding the full catalog.
- Strong fuzzy matches (≥75% single channel, ≥80% bulk) skip ML
entirely, avoiding a \~500MB PyTorch load when the fuzzy result is
already reliable.
- Bulk matching uses a single fuzzy pass per channel instead of scanning
the full catalog twice for best match and top candidates.
- Bulk exact `tvg_id` / Gracenote matching uses an in-memory index built
alongside the EPG catalog (`build_epg_matching_catalog()`), giving O(1)
lookups with no extra database queries.
- Bulk match apply uses batched queries (two fetches plus `bulk_update`)
instead of one `EPGData.objects.get()` per matched channel.
- EPG normalization settings are cached once per matching run, avoiding
repeated `CoreSettings` reads when normalizing thousands of names.

##### Fixed

- **Live proxy channels could remain running with no clients after
disconnect.** `stop_channel` called `log_system_event('channel_stop')`
synchronously before local cleanup and Redis key deletion; Connect
integrations or DB event writes on that path could block teardown
indefinitely while the cleanup thread kept refreshing metadata TTL for a
stale `stream_buffers` entry. Teardown now signals shutdown
(`buffer.stopping`), runs model `release_stream()` and Redis key
deletion, releases ownership, stops ffmpeg/output managers and local
buffers, and only then logs the stop event asynchronously. Metadata TTL
refresh skips channels mid-shutdown and non-owned channels; a stuck-stop
watchdog forces cleanup if `stop_channel` does not return within \~10s
(or 2× `channel_shutdown_delay`, whichever is greater). Stream buffers
ignore late `add_chunk()` writes once shutdown begins (`buffer.stopping`
set at teardown start).
- **Client reconnect during channel teardown could wedge the channel
across uWSGI workers.** The disconnect path called
`proxy_server.stop_channel()` directly, so other workers were not
notified and reconnecting clients could attach while ownership was
released on the owner worker. The cleanup thread then re-acquired
expired ownership and looped on orphaned clients while the upstream
connection stayed open. All lifecycle stops now go through coordinated
Redis teardown (`channel_stopping` flag, metadata `stopping` state, and
`CHANNEL_STOP` pubsub). New stream requests are rejected with `503
Retry-After` only during active teardown (not during the post-disconnect
shutdown delay grace period); `initialize_channel()` and ownership
re-acquisition refuse to proceed in those states; non-owner workers
clean local resources only on pubsub; and orphaned-client sweeps force
cleanup when teardown is already active. (Fixes
[#&#8203;1342](https://redirect.github.com/Dispatcharr/Dispatcharr/issues/1342))
- **Orphaned upstream threads kept writing Redis after teardown.**
Partial cleanup could remove a channel from `stream_managers` while the
`stream-{uuid}` OS thread kept running, so orphan metadata sweeps only
deleted Redis keys and chunks/metadata were immediately recreated (bare
`total_bytes` hash with TTL -1). Stream managers now stop upstream when
ownership is lost, orphan cleanup stops local ffmpeg/stream threads even
when registry entries are gone (`_live_stream_managers` tracks managers
until the thread exits), and forced recovery stops processes before
Redis deletion instead of dropping dict entries without calling
`stop()`.
- **Rapid channel switching could leave bare `buffer:index` keys in
Redis.** `buffer.stop()` flushed a final partial chunk via `INCR` during
teardown, creating a persistent index key (TTL -1) after chunk keys
expired; under load overlapping disconnect and cleanup-thread stops
could race on `_stop_local_stream_activity`, blocking on ffmpeg stderr
join before `_clean_redis_keys` ever ran. Teardown no longer writes to
Redis from `buffer.stop()`, disconnect uses coordinated stop only (no
duplicate upstream stop), model `release_stream()` runs before Redis
keys are scanned/deleted (so `profile_connections` counters are not left
stuck), ownership is released after Redis cleanup but before the
blocking local ffmpeg stop, and a `finally` block guarantees Redis
cleanup if local teardown raises.
- **Live proxy could leak geventpool DB checkouts outside HTTP
requests.** With `django-db-geventpool`, `connection.close()` returns
handles to the per-worker pool (`MAX_CONNS=8`); without it, greenlets
and OS threads keep connections checked out until the pool blocks on
`pool.get()`. Proxy paths that touch the ORM outside Django's request
cycle now call `close_old_connections()` after work completes:
`_clean_redis_keys()`, profile lookup in
`_establish_transcode_connection()` before spawning ffmpeg, and fMP4
client disconnect cleanup when releasing streams (TS disconnect relies
on `log_system_event()`). (Fixes
[#&#8203;1345](https://redirect.github.com/Dispatcharr/Dispatcharr/issues/1345))
- **System events could block callers on Connect and plugin handlers.**
`log_system_event()` ran Connect subscriptions and plugin `"events"`
hooks synchronously after the DB write, so slow integrations could stall
live-proxy and streaming paths even when inserting the event row was
fast. Connect/plugin dispatch now runs on a separate gevent when the hub
is available (synchronously in Celery workers without a hub).
`log_system_event()` and `dispatch_event_system()` also call
`close_old_connections()` in `finally` blocks so integration work does
not leave pool slots checked out on the caller or dispatch greenlet.
- **Plugins could leak geventpool DB checkouts after UI or Connect event
runs.** Third-party plugins run inline on uWSGI greenlets (manual
actions and Connect `"events"` hooks) with no guaranteed connection
cleanup at the plugin boundary. `PluginManager.run_action()` and
`stop_plugin()` now call `close_old_connections()` in a `finally` block
so each action returns its pool slot whether the plugin succeeds or
raises.
- **Connect events repeatedly queried the full plugin catalog during
streaming.** `trigger_event()` called `list_plugins()` on every
`client_connect` / `client_disconnect`, loading all `PluginConfig` rows
and sometimes hitting plugin-repo work even when no plugin subscribed to
the event. Dispatch now walks the in-memory registry via
`iter_actions_for_event()`, returns immediately when no handlers exist,
and runs a single batched `enabled` lookup for matching plugins only.
Failed plugin actions are logged per handler instead of aborting the
rest.
- **Plugin discovery left idle Postgres backends after worker boot.**
`discover_plugins()` runs outside Django's request cycle during uWSGI
and Celery startup; it now calls `close_old_connections()` in a
`finally` block so bootstrap `PluginConfig` queries return their pool
slot instead of appearing as long-lived idle connections in
`pg_stat_activity`.
- **VOD proxy could leak geventpool DB checkouts during playback and
stats updates.** `stream_vod()` ran ORM lookups for content and M3U
profiles, then returned a long-lived `StreamingHttpResponse` without
releasing the checkout, so each movie/episode stream could hold a pool
slot for its full duration. Background VOD stats refresh
(`build_vod_stats_data()`, triggered on start/stop and by the admin
stats API) also queried movie, episode, and profile rows from daemon
threads with no cleanup. `stream_vod()` now calls
`close_old_connections()` before handing off to the streaming generator,
and `build_vod_stats_data()` releases its checkout in a `finally` block.
- **Channel shutdown delay did not reset after a reconnect within the
grace period.** `handle_client_disconnect()` used a fixed
`gevent.sleep(shutdown_delay)` from the first last-client disconnect. If
a client reconnected and disconnected again during the delay, an earlier
disconnect handler could still stop the channel on the original timer
instead of waiting the full delay from the latest disconnect. Shutdown
now polls Redis (`last_client_disconnect` timestamp and client count) so
concurrent disconnect handlers and multi-worker reconnects always honour
the latest disconnect time.
- **Zombie ffmpeg could survive owner-lock expiry and orphan Redis
sweeps.** When the 30s owner lock lapsed under single-worker load,
disconnect handling treated the worker as non-owner so coordinated stop
never ran, while ffmpeg kept writing and the orphan sweeper only deleted
Redis keys (recreating them immediately). Disconnect now re-acquires
ownership when local upstream is still active, stops locally when the
last client leaves without a lock, orphan cleanup stops local ffmpeg
before Redis deletion via `_has_local_upstream_activity`, re-init stops
lingering upstream before starting a duplicate thread, and
`is_channel_teardown_active` includes channels mid-`stop_channel` on
this worker so rapid reconnect gets 503 during teardown.
- **Stale `channel_stream` Redis keys after a channel stopped could skip
connection accounting on retune.** On `dev`, `get_stream()` reused any
existing `channel_stream` / `stream_profile` assignment without
reserving a new slot. If those keys were left behind after a stop, the
next tune-in could reach the provider without incrementing Redis
counters. `get_stream()` now releases stale assignments when proxy
metadata shows the channel is inactive, then reserves fresh slots.
- **EPG auto-match reliability fixes.**
- Memory could spike to multiple GB on large EPG sources when building a
full in-memory catalog before fuzzy matching; single-channel matching
now streams rows and bounds ML work to a small candidate set.
- Wrong channel assignments from global ML similarity; ML validation now
checks the fuzzy best match (or top fuzzy candidates as a last resort)
instead of scoring the entire catalog.
- Channel form auto-match spinner could stick after errors or early task
exits; all single-channel outcomes now push a WebSocket result, and the
UI clears loading state after a 3-minute timeout.
- Bulk auto-match completion no longer calls `batch-set-epg` from the
WebSocket handler, which had been re-applying every match and queueing
redundant `parse_programs_for_tvg_id` tasks even when assignments were
unchanged.
- **Schedules Direct lineup search country dropdown.** The country list
was fetched directly from the SD API in the browser, which failed due to
CORS and silently fell back to a 14-country hardcoded list. Countries
are now included in the `GET sd-lineups` response (server-side fetch
with proper User-Agent) so the full SD country list populates correctly.
— Thanks [@&#8203;sethwv](https://redirect.github.com/sethwv)
- **Schedules Direct program poster proxy omitted User-Agent on image
requests.** The poster endpoint authenticated with SD correctly but
fetched images with only the `token` header, which violates SD's API
requirements (error 1003). Image requests now include the standard
`Dispatcharr/{version}` User-Agent via `dispatcharr_http_headers()`.
- **Schedules Direct guide data missing after mapping a channel.**
Lineup refreshes cached schedule MD5s for all stations, but
`ProgramData` was only written for mapped channels. Mapping a channel
later could leave MD5s looking unchanged so schedules were skipped and
the channel had no guide until dates rolled outside the cached window.
Refreshes now backfill fetch-window dates that lack `ProgramData`
(including newly mapped stations with stale cache), fetch program
metadata when no local `ProgramData` exists for a `programID`, and clean
up orphaned `ProgramData` on unmapped `EPGData` entries. — Thanks
[@&#8203;sethwv](https://redirect.github.com/sethwv)
- **Schedules Direct guide fetch on channel map.** Mapping a channel (or
bulk-assigning EPG) now triggers a targeted guide fetch for that
`EPGData` entry—mirroring XMLTV's `parse_programs_for_tvg_id`
flow—without waiting for the next full source refresh. Skips the fetch
when `ProgramData` already exists so additional channels sharing the
same `tvg-id` do not trigger redundant API calls. Bulk assignment of
three or more SD stations without guide data on the same source queues
one batched mapped-station fetch instead of separate per-station API
sessions. Concurrent batch and single-EPG fetches coordinate via
source-level locks with deferred retries so mappings are not dropped and
overlapping SD API sessions are avoided when possible.
- **Auto-sync numbering modes now read only the fields each mode's UI
exposes.** After the auto-sync overhaul, switching between Provider,
Next Available, and Fixed modes left stale `auto_sync_channel_start` /
`auto_sync_channel_end` values in the database while each mode's UI only
edits a subset of those fields. Sync treated the hidden values as
authoritative in every mode, which discarded valid provider numbers
(floored at an auto-computed start), capped Next Available at a stale
End, and ran range-enforcement deletes against provider- and
next-available-numbered channels. Provider mode now honors `stream_chno`
verbatim when free (Start/End bound only the fallback for numberless
streams); Next Available ignores End; overflow-delete runs in Fixed mode
only. Duplicate or already-taken provider numbers fall back to a free
slot instead of being dropped or overwriting an existing channel.
Provider mode's Start # field now drops End when it would invert the
fallback range (matching Fixed mode). (Closes
[#&#8203;1273](https://redirect.github.com/Dispatcharr/Dispatcharr/issues/1273))
— Thanks [@&#8203;CodeBormen](https://redirect.github.com/CodeBormen)

</details>

---

### Configuration

📅 **Schedule**: (UTC)

- Branch creation
  - At any time (no schedule defined)
- Automerge
  - At any time (no schedule defined)

🚦 **Automerge**: Enabled.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

This PR has been generated by [Renovate
Bot](https://redirect.github.com/renovatebot/renovate).

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0My4xMzAuMSIsInVwZGF0ZWRJblZlciI6IjQzLjEzMC4xIiwidGFyZ2V0QnJhbmNoIjoibWFzdGVyIiwibGFiZWxzIjpbImFwcC9kaXNwYXRjaGFyciIsImF1dG9tZXJnZSIsInJlbm92YXRlL2NvbnRhaW5lciIsInR5cGUvbWlub3IiXX0=-->

charts/stable/dispatcharr/Chart.yaml

@@ -9,7 +9,7 @@ annotations:
   trueforge.org/min_helm_version: "3.14"
   trueforge.org/train: stable
 apiVersion: v2
-appVersion: 0.26.0
+appVersion: 0.27.0
 dependencies:
   - name: common
     version: 29.5.3
@@ -37,5 +37,5 @@ sources:
   - https://github.com/trueforge-org/truecharts/tree/master/charts/stable/dispatcharr
   - https://hub.docker.com/r/dispatcharr/dispatcharr
 type: application
-version: 2.10.0
+version: 2.11.0
 

charts/stable/dispatcharr/values.yaml

@@ -2,7 +2,7 @@
 image:
   pullPolicy: IfNotPresent
   repository: docker.io/dispatcharr/dispatcharr
-  tag: 0.26.0@sha256:9275b0c1f5319a84b412af6839a1364ef25b61d8d6ff0d2130a6c2b2504a8b07
+  tag: 0.27.0@sha256:425129020764037869c7d1a2e74ba57ca640cb5d551ef57d869b745b6ea71c7b
 securityContext:
   container:
     readOnlyRootFilesystem: false