Method destroy

apps/channels/api_views.py:3747–3914

Delete the Recording and ensure any active DVR client connection is closed. Also removes the associated file(s) from disk if present. Operation order matters for correctness: 1. Delete the DB record first — run_recording's cancellation guard (Recording.object

(self, request, *args, **kwargs)

        return Response({"success": True})

    def destroy(self, request, *args, **kwargs):
        """Delete the Recording and ensure any active DVR client connection is closed.

        Also removes the associated file(s) from disk if present.

        Operation order matters for correctness:
          1. Delete the DB record first — run_recording's cancellation guard
             (Recording.objects.filter(id=...).exists()) will now return False,
             preventing it from saving 'interrupted' status or sending
             recording_ended after the stream is torn down.
          2. Send recording_cancelled WebSocket immediately so the frontend
             removes the card without waiting for the slow DVR client teardown.
          3. Spawn a background thread to stop the DVR client and delete files.
             This mirrors the stop() endpoint's approach and avoids the 5-15 s
             delay that _stop_dvr_clients() can introduce.
        """
        instance = self.get_object()
        recording_id = instance.pk
        channel_name = instance.channel.name

        # Attempt to close the DVR client connection for this channel if active
        try:
            channel_uuid = str(instance.channel.uuid)
            # Lazy imports to avoid module overhead if proxy isn't used
            from core.utils import RedisClient
            from apps.proxy.live_proxy.redis_keys import RedisKeys
            from apps.proxy.live_proxy.services.channel_service import ChannelService

            r = RedisClient.get_client()
            if r:
                client_set_key = RedisKeys.clients(channel_uuid)
                client_ids = r.smembers(client_set_key) or []
                stopped = 0
                for cid in client_ids:
                    try:
                        meta_key = RedisKeys.client_metadata(channel_uuid, cid)
                        ua = r.hget(meta_key, "user_agent")
                        # Identify DVR recording client by its user agent
                        if ua and "Dispatcharr-DVR" in ua:
                            try:
                                ChannelService.stop_client(channel_uuid, cid)
                                stopped += 1
                            except Exception as inner_e:
                                logger.debug(f"Failed to stop DVR client {cid} for channel {channel_uuid}: {inner_e}")
                    except Exception as inner:
                        logger.debug(f"Error while checking client metadata: {inner}")
                if stopped:
                    logger.info(f"Stopped {stopped} DVR client(s) for channel {channel_uuid} due to recording cancellation")
                # If no clients remain after stopping DVR clients, proactively stop the channel
                try:
                    remaining = r.scard(client_set_key) or 0
                except Exception:
                    remaining = 0
                if remaining == 0:
                    try:
                        ChannelService.stop_channel(channel_uuid)
                        logger.info(f"Stopped channel {channel_uuid} (no clients remain)")
                    except Exception as sc_e: