trackservice.py

#
# Aura Engine (https://gitlab.servus.at/aura/engine)
#
# Copyright (C) 2020 - The Aura Engine Team.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import json
import logging
import requests

from collections                import deque

from src.base.config            import AuraConfig
from src.base.utils             import SimpleUtil as SU
from src.resources              import ResourceClass
from src.resources              import ResourceUtil
from src.scheduling.fallback    import FallbackType



class TrackServiceHandler():
    """
    Sends the trackservice entry and studio clock information to the `engine-api` REST endpoint.
    """
    logger = None
    config = None
    engine = None
    playlog = None


    def __init__(self, engine):
        """
        Initialize.
        """
        self.logger = logging.getLogger("AuraEngine")
        self.config = AuraConfig.config()
        self.engine = engine
        self.playlog = Playlog(engine)



    def on_timeslot_start(self, timeslot=None):
        """
        Some new timeslot has just started.
        """
        if timeslot:
            self.logger.info(f"Active timeslot used for trackservice '{timeslot}'")
        self.playlog.set_timeslot(timeslot)



    def on_timeslot_end(self, timeslot):
        """
        Called when a timeslot ends.
        """
        if timeslot:
            self.logger.info(f"Timeslot '{timeslot}' just ended")
        self.playlog.set_timeslot(None)



    def on_queue(self, entries):
        """
        Items have been queued. They are stored to the local playlog, allowing later
        matching and retrieval to augment meta-information.

        Args:
            entries ([PlaylistEntry]):  The entries which got queued
        """
        for entry in entries:
            self.playlog.add(entry)


    def on_play(self, entry):
        """
        Some `PlaylistEntry` started playing. This is likely only a LIVE or STREAM entry.
        """
        content_class = ResourceUtil.get_content_class(entry.get_content_type())
        if content_class == ResourceClass.FILE:
            # Files are handled by "on_metadata" called via Liquidsoap
            return

        diff = (entry.entry_start_actual - entry.entry_start).total_seconds()
        self.logger.info("There's a difference of %s seconds between planned and actual start of the entry" % diff)

        data = {}
        data["track_start"] = entry.entry_start_actual
        if entry.meta_data:
            data["track_artist"] = entry.meta_data.artist
            data["track_album"] = entry.meta_data.album
            data["track_title"] = entry.meta_data.title
        data["track_duration"] = entry.duration
        data["track_num"] = entry.entry_num
        data["track_type"] = content_class.numeric
        data["playlist_id"] = entry.playlist.playlist_id
        data["timeslot_id"] = entry.playlist.timeslot.timeslot_id
        data["show_id"] = entry.playlist.timeslot.show_id
        data["show_name"] = entry.playlist.timeslot.show_name
        data["log_source"] = self.config.get("api_engine_number")

        self.store_trackservice(data)
        self.store_clock_info(data)



    def on_metadata(self, meta):
        """
        Some metadata update was sent from Liquidsoap.
        """
        data = {}
        data["track_start"] = meta.get("on_air")
        data["track_artist"] = meta.get("artist")
        data["track_album"] = meta.get("album")
        data["track_title"] = meta.get("title")
        data["track_type"] = ResourceClass.FILE.numeric
        #lqs_source = meta["source"]

        if "duration" in meta:
            duration = float(meta.get("duration"))
            data["track_duration"] = int(duration)
        else:
            data["track_duration"] = 0

        entry = self.playlog.resolve_entry(meta["filename"])

        if entry:
            # This is a playlog according to the scheduled playlist (normal or fallback)
            data["track_num"] = entry.entry_num
            data["playlist_id"] = entry.playlist.playlist_id
            data["timeslot_id"] = entry.playlist.timeslot.timeslot_id
            data["show_id"] = entry.playlist.timeslot.show_id
            data["show_name"] = entry.playlist.timeslot.show_name
        else:
            # This is a fallback playlog which wasn't scheduled actually (e.g. station fallback)
            (past, timeslot, next) = self.playlog.get_timeslots()
            if timeslot:
                data = {**data, **timeslot}
                data["playlist_id"] = -1

        data["log_source"] = self.config.get("api_engine_number")
        data = SU.clean_dictionary(data)
        self.store_trackservice(data)
        self.store_clock_info(data)



    def store_trackservice(self, data):
        """
        Posts the given `PlaylistEntry` to the Engine API Playlog.
        """
        data = SU.clean_dictionary(data)

        self.logger.info("Posting playlog to Engine API...")
        url = self.config.get("api_engine_store_playlog")
        headers = {'content-type': 'application/json'}
        body = json.dumps(data, indent=4, sort_keys=True, default=str)
        self.logger.debug("Playlog Data: " + body)
        response = requests.post(url, data=body, headers=headers)
        if response.status_code != 204 or response.status_code != 204:
            msg = f"Error while posting playlog to Engine API: {response.reason} (Error {response.status_code})\n"
            self.logger.info(SU.red(msg) + response.content.decode("utf-8"))


    def store_clock_info(self, data):
        """
        Posts the current and next show information to the Engine API.
        """
        planned_playlist = None
        if self.engine.scheduler:
            (playlist_type, planned_playlist) = self.engine.scheduler.get_active_playlist()
        (past_timeslot, current_timeslot, next_timeslot) = self.playlog.get_timeslots()

        data = dict()
        data["engine_source"] = self.config.get("api_engine_number")

        if current_timeslot:
            data["current_timeslot"] = current_timeslot

            if planned_playlist:
                data["planned_playlist"] = dict()
                data["planned_playlist"]["playlist_id"] = planned_playlist.playlist_id
                data["planned_playlist"]["entries"] = []
                for e in planned_playlist.entries:
                    entry = dict()
                    entry["track_start"] = e.entry_start
                    if e.meta_data:
                        entry["track_artist"] = e.meta_data.artist
                        entry["track_album"] = e.meta_data.album
                        entry["track_title"] = e.meta_data.title
                    entry["track_num"] = e.entry_num
                    entry["track_duration"] = e.duration
                    content_class = ResourceUtil.get_content_class(e.get_content_type())
                    entry["track_type"] = content_class.numeric
                    entry = SU.clean_dictionary(entry)
                    data["planned_playlist"]["entries"].append(entry)

        if next_timeslot:
            data["next_timeslot"] = next_timeslot


        data = SU.clean_dictionary(data)

        self.logger.info("Posting clock info update to Engine API...")
        url = self.config.get("api_engine_store_clock")
        headers = {'content-type': 'application/json'}
        body = json.dumps(data, indent=4, sort_keys=True, default=str)
        self.logger.debug("Clock Data: " + body)
        response = requests.put(url, data=body, headers=headers)
        if response.status_code != 204 or response.status_code != 204:
            msg = f"Error while posting clock-info to Engine API: {response.reason} (Error {response.status_code})\n"
            self.logger.info(SU.red(msg) + response.content.decode("utf-8"))




class Playlog:
    """
    Playlog keeps a history of currently queued (and playing) entries. It stores the recent
    active entries to a local cache `history` being able to manage concurrently playing entries.
    It also is in charge of resolving relevant meta information of the currently playing entry for
    the TrackService handler.

    The records are stored in pre-formatted dictionary structure, allowing easy serialization when
    posting them to the Engine API.
    """
    config = None
    logger = None
    engine = None
    history = None
    previous_timeslot = None
    current_timeslot = None
    next_timeslot = None


    def __init__(self, engine):
        """
        Constructor
        """
        self.config = AuraConfig.config()
        self.logger = logging.getLogger("AuraEngine")
        self.engine = engine
        self.history = deque(maxlen=100)
        self.current_timeslot = {}
        self.init_timeslot(None)



    def init_timeslot(self, next_timeslot=None):
        """
        Initializes the timeslot.
        """
        data = {}
        self.assign_fallback_playlist(data, None)
        data["timeslot_id"] = -1
        data["show_id"] = -1
        data["show_name"] = ""

        if self.previous_timeslot:
            data["timeslot_start"] = self.previous_timeslot.get("timeslot_end")
        else:
            data["timeslot_start"] = None

        if next_timeslot:
            data["timeslot_end"] = next_timeslot.timeslot_start
        else:
            data["timeslot_end"] = None

        self.current_timeslot = data



    def set_timeslot(self, timeslot):
        """
        Sets the current timeslot and proper default values if no timeslot is available.
        Any previous timeslot is stored to `self.previous_timeslot` and the following one
        to `self.next_timeslot`.

        This method is protect by overwriting by multiple calls with the same timeslot.

        Args:
            timeslot (Timeslot):    The current timeslot
        """
        if timeslot and self.previous_timeslot:
            if self.previous_timeslot.get("timeslot_start") == timeslot.timeslot_start:
                return # Avoid overwrite by multiple calls in a row

        data = {}
        next_timeslot = self.engine.scheduler.get_programme().get_next_timeslots(1)
        if next_timeslot:
            next_timeslot = next_timeslot[0]
        else:
            next_timeslot = None

        # A valid timeslot from the scheduler is available
        if timeslot:
            self.assign_fallback_playlist(data, timeslot)
            data["timeslot_id"] = timeslot.timeslot_id
            data["timeslot_start"] = timeslot.timeslot_start
            data["timeslot_end"] = timeslot.timeslot_end
            data["show_id"] = timeslot.show_id
            data["show_name"] = timeslot.show_name
            data = SU.clean_dictionary(data)

            # Any previous (fake) timeslots should get the proper end now
            if not self.previous_timeslot:
                self.current_timeslot["timeslot_end"] = timeslot.timeslot_start
            self.previous_timeslot = self.current_timeslot
            self.current_timeslot = data

        # Defaults for a not existing timeslot
        else:
            self.init_timeslot(next_timeslot)

        # A valid following timeslot is available
        self.next_timeslot = None
        if next_timeslot:
            ns = {}
            self.assign_fallback_playlist(ns, next_timeslot)
            ns["timeslot_id"] = next_timeslot.timeslot_id
            ns["timeslot_start"] = next_timeslot.timeslot_start
            ns["timeslot_end"] = next_timeslot.timeslot_end
            ns["show_id"] = next_timeslot.show_id
            ns["show_name"] = next_timeslot.show_name
            ns["playlist_id"] = next_timeslot.playlist_id
            ns = SU.clean_dictionary(ns)
            self.next_timeslot = ns



    def assign_fallback_playlist(self, data, timeslot):
        """
        Assigns fallback info to the given timeslot.

        Args:
            data ({}):              The dictionary holding the (virtual) timeslot
            timeslot (Timeslot):    The actual timeslot object to retrieve fallback info from
        """
        playlist_type = None
        playlist = None

        if timeslot:
            playlist_type, playlist = self.engine.scheduler.resolve_playlist(timeslot)

        if playlist:
            data["playlist_id"] = playlist.playlist_id
        else:
            data["playlist_id"] = -1

        #FIXME "fallback_type" should be a more generic "playout_state"? (compare meta#42)
        #FIXME Add field for "playlist_type", which now differs from playout-state
        #FIXME Remove dependency to "scheduler" and "scheduler.fallback" module
        data["fallback_type"] = 0
        if self.engine.scheduler:
            playout_state = self.engine.scheduler.fallback.get_playout_state()
            data["fallback_type"] = playout_state.id

        # if playlist_type:
        #     data["fallback_type"] = playlist_type.id
        # else:
        #     data["fallback_type"] = FallbackType.STATION.id


    def get_timeslots(self):
        """
        Retrieves all available timeslots for the past, future and the current one.

        Returns:
            ({}, {}, {})
        """
        return (self.previous_timeslot, self.current_timeslot, self.next_timeslot)


    def add(self, entry):
        """
        Saves the currently preloaded [`Entry`] to the local cache.
        """
        self.history.append(entry)


    def get_recent_entries(self):
        """
        Retrieves the currently playing [`Entry`] from the local cache.
        """
        return self.history


    def resolve_entry(self, uri):
        """
        Retrieves the playlog matching the provided file URI.

        Args:
            path (String):    The URI of the resource
        """
        result = None
        entries = self.get_recent_entries()
        if not entries:
            return None

        for entry in entries:
            if entry:
                entry_source = entry.source

                if entry.get_content_type() in ResourceClass.FILE.types:
                    base_dir = self.config.abs_audio_store_path()
                    extension = self.config.get("audio_source_extension")
                    entry_source = ResourceUtil.source_to_filepath(base_dir, entry.source, extension)
                if entry_source == uri:
                    self.logger.info("Resolved '%s' entry '%s' for URI '%s'" % (entry.get_content_type(), entry, uri))
                    result = entry
                    break

        if not result:
            msg = "Found no entry in the recent history which matches the given source '%s'" % (uri)
            self.logger.info(msg)

        return result


    def print_entry_history(self):
        """
        Prints all recents entries of the history.
        """
        msg = "Active entry history:\n"
        for entries in self.history:
            msg += "["
            for e in entries:
                msg += "\n" + str(e)
            msg += "]"
        self.logger.info(msg)