fallback.py 10.3 KB
Newer Older
David Trattnig's avatar
David Trattnig committed
1
2

#
David Trattnig's avatar
David Trattnig committed
3
# Aura Engine (https://gitlab.servus.at/aura/engine)
David Trattnig's avatar
David Trattnig committed
4
#
David Trattnig's avatar
David Trattnig committed
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Copyright (C) 2017-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/>.

David Trattnig's avatar
David Trattnig committed
20
21


David Trattnig's avatar
David Trattnig committed
22
import logging
David Trattnig's avatar
David Trattnig committed
23

24
25
from enum                   import Enum
from datetime               import timedelta
David Trattnig's avatar
David Trattnig committed
26

27
28
from src.base.config        import AuraConfig
from src.base.utils         import SimpleUtil as SU
29
from src.core.resources     import ResourceClass, ResourceUtil
30
31
from src.core.channels      import Channel
from src.core.control       import EngineExecutor
32

David Trattnig's avatar
David Trattnig committed
33
34
35
36


class FallbackType(Enum):
    """
37
38
39
40
41
42
    Types of fallbacks.

        NONE:       No fallback active, default playout
        SCHEDULE:   The first played when some default playlist fails
        SHOW:       The second played when the timeslot fallback fails
        STATION:    The last played when everything else fails
David Trattnig's avatar
David Trattnig committed
43
    """
44
45
46
47
    NONE        = { "id": 0, "name": "default", "channels": [ Channel.QUEUE_A, Channel.QUEUE_B ] }
    SCHEDULE    = { "id": 1, "name": "schedule", "channels": [ Channel.FALLBACK_QUEUE_A, Channel.FALLBACK_QUEUE_B ] }   
    SHOW        = { "id": 2, "name": "show", "channels": [ Channel.FALLBACK_QUEUE_A, Channel.FALLBACK_QUEUE_B ] }
    STATION     = { "id": 3, "name": "station", "channels": [ Channel.FALLBACK_STATION_FOLDER, Channel.FALLBACK_STATION_PLAYLIST ] }
David Trattnig's avatar
David Trattnig committed
48
49
50
51
52

    @property
    def id(self):
        return self.value["id"]

53
54
55
56
    @property
    def channels(self):
        return self.value["channels"]

David Trattnig's avatar
David Trattnig committed
57
58
59
    def __str__(self):
        return str(self.value["name"])

David Trattnig's avatar
David Trattnig committed
60

David Trattnig's avatar
David Trattnig committed
61

David Trattnig's avatar
David Trattnig committed
62
63
class FallbackManager:
    """
64
65
    Handles all types of fallbacks in case there is an outage or missing schedules
    for the radio programme.
David Trattnig's avatar
David Trattnig committed
66
    """    
David Trattnig's avatar
David Trattnig committed
67
68
    config = None
    logger = None
69
70
    engine = None
    state = None
David Trattnig's avatar
David Trattnig committed
71
    
72
73

    def __init__(self, engine):
David Trattnig's avatar
David Trattnig committed
74
75
76
77
        """
        Constructor

        Args:
78
            scheduler (Scheduler):  The scheduler
David Trattnig's avatar
David Trattnig committed
79
        """
80
81
        self.config = AuraConfig.config()
        self.logger = logging.getLogger("AuraEngine")
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
        self.engine = engine
        self.state = {            
            "fallback_type": FallbackType.NONE,
            "previous_fallback_type": None, 
            "timeslot": None
        }


    #
    #   EVENTS
    #


    def on_timeslot_start(self, timeslot=None):
        """
        Some new timeslot has just started.
        """        
        self.state["timeslot"] = timeslot


    def on_timeslot_end(self, timeslot):
        """
        The timeslot has ended and the state is updated. The method ensures that any intermediate state update doesn't get overwritten.
        """        
        if self.state["timeslot"] == timeslot:
            self.state["timeslot"] = None


    def on_play(self, entry):
        """
        Event Handler which is called by the engine when some entry is actually playing. 

        Args:
            source (String):    The `PlaylistEntry` object
116
117
118
119
120
121
        """     
        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

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
        self.update_fallback_state(entry.channel)


    def on_metadata(self, data):
        """
        Event called by the soundsystem implementation (i.e. Liquidsoap) when some entry is actually playing. 
        This does not include live or stream sources, since they ain't have metadata and are triggered from 
        engine core (see `on_play(..)`).

        Args:
            data (dict):    A collection of metadata related to the current track
        """
        channel = data.get("source")
        fallback_type = self.update_fallback_state(channel)

        # If we turned into a fallback state we issue an event
        if fallback_type is not FallbackType.NONE:
            # Only trigger the event the upon first state change
            if fallback_type != self.state.get("previous_fallback_type"):
                self.engine.event_dispatcher.on_fallback_active(self.state["timeslot"], fallback_type)

David Trattnig's avatar
David Trattnig committed
143
144
145


    #
146
    #   METHODS
David Trattnig's avatar
David Trattnig committed
147
148
    #

149

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
    def update_fallback_state(self, channel):
        """
        Update the current and previously active fallback state.

        Returns:
            (FallbackType): The current fallback
        """
        fallback_type = self.type_for_channel(channel)
        self.state["previous_fallback_type"] = self.state["fallback_type"]
        self.state["fallback_type"] = fallback_type
        return fallback_type


    def type_for_channel(self, source):
        """
        Retrieves the matching fallback type for the given source.
        """
        if source in [str(i) for i in FallbackType.SCHEDULE.channels]:
            return FallbackType.SCHEDULE
        if source in [str(i) for i in FallbackType.SHOW.channels]:
            return FallbackType.SHOW
        if source in [str(i) for i in FallbackType.STATION.channels]:
            return FallbackType.STATION
        return FallbackType.NONE


176
    def queue_fallback_playlist(self, timeslot):
David Trattnig's avatar
David Trattnig committed
177
        """
David Trattnig's avatar
David Trattnig committed
178
        Evaluates the scheduled fallback and queues it using a timed thread.
David Trattnig's avatar
David Trattnig committed
179
        """
180
        (fallback_type, playlist) = self.get_fallback_playlist(timeslot)
David Trattnig's avatar
David Trattnig committed
181
182

        if playlist:
183
184
            self.logger.info(f"Resolved {fallback_type.value} fallback")         
            return FallbackCommand(timeslot, playlist.entries)
David Trattnig's avatar
David Trattnig committed
185
        else:
186
            msg = f"There is no timeslot- or show-fallback defined for timeslot#{timeslot.timeslot_id}. "
David Trattnig's avatar
David Trattnig committed
187
188
            msg += f"The station fallback will be used automatically."
            self.logger.info(msg)
David Trattnig's avatar
David Trattnig committed
189
190
191



192
    def resolve_playlist(self, timeslot):
David Trattnig's avatar
David Trattnig committed
193
        """
David Trattnig's avatar
David Trattnig committed
194
195
        Retrieves the currently planned (fallback) playlist. If a normal playlist is available,
        this one is returned. In case of station fallback no playlist is returned.
David Trattnig's avatar
David Trattnig committed
196

David Trattnig's avatar
David Trattnig committed
197
        Args:
198
            timeslot (Timeslot)
David Trattnig's avatar
David Trattnig committed
199
        
David Trattnig's avatar
David Trattnig committed
200
        Returns:
David Trattnig's avatar
David Trattnig committed
201
            (FallbackType, Playlist)
David Trattnig's avatar
David Trattnig committed
202
        """
David Trattnig's avatar
David Trattnig committed
203
204
        planned_playlist = None
        fallback_type = None
David Trattnig's avatar
David Trattnig committed
205

206
        if self.validate_playlist(timeslot, "playlist"):
David Trattnig's avatar
David Trattnig committed
207
            planned_playlist = timeslot.playlist
David Trattnig's avatar
David Trattnig committed
208
            fallback_type = FallbackType.NONE
David Trattnig's avatar
David Trattnig committed
209
        else:
210
            (fallback_type, planned_playlist) = self.get_fallback_playlist(timeslot)            
David Trattnig's avatar
David Trattnig committed
211

David Trattnig's avatar
David Trattnig committed
212
        return (fallback_type, planned_playlist)
David Trattnig's avatar
David Trattnig committed
213
214
215



216
    def get_fallback_playlist(self, timeslot):
217
        """
David Trattnig's avatar
David Trattnig committed
218
        Retrieves the playlist to be used in a fallback scenario.
219

David Trattnig's avatar
David Trattnig committed
220
        Args: 
221
            timeslot (Timeslot)
222

David Trattnig's avatar
David Trattnig committed
223
        Returns:
David Trattnig's avatar
David Trattnig committed
224
            (Playlist) 
David Trattnig's avatar
David Trattnig committed
225
226
227
        """        
        playlist = None
        fallback_type = FallbackType.STATION
David Trattnig's avatar
David Trattnig committed
228

229
        if self.validate_playlist(timeslot, "schedule_fallback"):
David Trattnig's avatar
David Trattnig committed
230
            playlist = timeslot.schedule_fallback
David Trattnig's avatar
David Trattnig committed
231
            fallback_type = FallbackType.SCHEDULE
232
        elif self.validate_playlist(timeslot, "show_fallback"):
David Trattnig's avatar
David Trattnig committed
233
            playlist = timeslot.show_fallback
David Trattnig's avatar
David Trattnig committed
234
235
236
            fallback_type = FallbackType.SHOW

        return (fallback_type, playlist)
David Trattnig's avatar
David Trattnig committed
237

David Trattnig's avatar
David Trattnig committed
238
239


240
    def validate_playlist(self, timeslot, playlist_type):
David Trattnig's avatar
David Trattnig committed
241
242
        """
        Checks if a playlist is valid for play-out.
David Trattnig's avatar
David Trattnig committed
243
244
245
246
247
248
249
250
251
252
253
254

        Following checks are done for all playlists:

            - has one or more entries

        Fallback playlists should either:
                
            - have filesystem entries only
            - reference a recording of a previous playout of a show (also filesystem)
        
        Otherwise, if a fallback playlist contains Live or Stream entries,
        the exact playout behaviour can hardly be predicted.
David Trattnig's avatar
David Trattnig committed
255
        """
256
        playlist = getattr(timeslot, playlist_type)
David Trattnig's avatar
David Trattnig committed
257
        if playlist \
David Trattnig's avatar
David Trattnig committed
258
259
            and playlist.entries \
            and len(playlist.entries) > 0:
David Trattnig's avatar
David Trattnig committed
260

David Trattnig's avatar
David Trattnig committed
261
262
263
264
265
            # Default playlist
            if playlist_type == "playlist":
                return True

            # Fallback playlist
David Trattnig's avatar
David Trattnig committed
266
            elif playlist.entries:
David Trattnig's avatar
David Trattnig committed
267
                is_fs_only = True
David Trattnig's avatar
David Trattnig committed
268
                for entry in playlist.entries:
David Trattnig's avatar
David Trattnig committed
269
270
271
272
273
274
275
                    if entry.get_content_type() not in ResourceClass.FILE.types:
                        self.logger.error(SU.red("Fallback playlist of type '%s' contains not only file-system entries! \
                            Skipping fallback level..." % playlist_type))
                        is_fs_only = False
                        break                
                return is_fs_only

David Trattnig's avatar
David Trattnig committed
276
277
278
279
280
281
        return False





David Trattnig's avatar
David Trattnig committed
282

283
class FallbackCommand(EngineExecutor):
David Trattnig's avatar
David Trattnig committed
284
    """
285
286
287
288
    Command composition for executing timed scheduling and unscheduling of fallback playlists.

    Based on the `timeslot.start_date` and `timeslot.end_date` two `EngineExecutor commands
    are created.
David Trattnig's avatar
David Trattnig committed
289
    """
290

291

292
    def __init__(self, timeslot, entries):
David Trattnig's avatar
David Trattnig committed
293
        """
David Trattnig's avatar
David Trattnig committed
294
        Constructor
295
296
297
298

        Args:
            timeslot (Timeslot):    The timeslot any fallback entries should be scheduled for
            entries (List):         List of entries to be scheduled as fallback
David Trattnig's avatar
David Trattnig committed
299
        """        
300
        from src.core.engine import Engine
301
302
303
304
305
306
307
308

        def do_play(entries):
            self.logger.info(SU.cyan(f"=== start_fallback_playlist('{entries}') ==="))
            Engine.get_instance().player.start_fallback_playlist(entries)

        def do_stop():
            self.logger.info(SU.cyan("=== stop_fallback_playlist() ==="))
            Engine.get_instance().player.stop_fallback_playlist()
David Trattnig's avatar
David Trattnig committed
309

310
311
        # Start fade-out 50% before the end of the timeslot for a more smooth transition
        end_time_offset = int(float(AuraConfig.config().get("fade_out_time")) / 2 * 1000 * -1)
312
        end_time = SU.timestamp(timeslot.timeslot_end + timedelta(milliseconds=end_time_offset))
313
        self.logger.info(f"Starting fade-out of scheduled fallback with an offset of {end_time_offset} milliseconds at {end_time}")
314
315
        super().__init__("FALLBACK", None, timeslot.start_unix, do_play, entries)
        EngineExecutor("FALLBACK", self, end_time, do_stop, None)