X-Git-Url: https://git.kaliko.me/?a=blobdiff_plain;f=sima%2Fcore.py;h=83c5e910a54adae79fc860b199a6c9913792bbdd;hb=774e755d4a4fb985548cd3d17703c1f700687ff3;hp=bf098bbb58ececa7d2442e0927d1009a7ef08e8b;hpb=0236b2bf31b893ab0b53374c0d3a0bc0ab9deda3;p=mpd-sima.git diff --git a/sima/core.py b/sima/core.py index bf098bb..83c5e91 100644 --- a/sima/core.py +++ b/sima/core.py @@ -1,72 +1,101 @@ # -*- coding: utf-8 -*- +# Copyright (c) 2009-2015, 2020, 2021 kaliko +# +# This file is part of sima +# +# sima is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# sima 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 General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with sima. If not, see . +# +# """Core Object dealing with plugins and player client """ -__version__ = '0.12.0pr1' -__author__ = 'kaliko jack' -__url__ = 'git://git.kaliko.me/sima.git' - -import sys import time from collections import deque from logging import getLogger -from .client import PlayerClient -from .client import PlayerError, PlayerUnHandledError +from .mpdclient import MPD as PlayerClient +from .mpdclient import PlayerError from .lib.simadb import SimaDB from .lib.daemon import Daemon from .utils.utils import SigHup + class Sima(Daemon): """Main class, plugin and player management """ def __init__(self, conf): - ## Set daemon + # Set daemon Daemon.__init__(self, conf.get('daemon', 'pidfile')) self.enabled = True self.config = conf self.sdb = SimaDB(db_path=conf.get('sima', 'db_file')) PlayerClient.database = self.sdb self.log = getLogger('sima') - self.plugins = list() - self.player = self.__get_player() # Player client - try: - self.player.connect() - except (PlayerError, PlayerUnHandledError) as err: - self.log.error('Fails to connect player: {}'.format(err)) - self.shutdown() + self._plugins = list() + self._core_plugins = list() + self.player = PlayerClient(conf) # MPD client self.short_history = deque(maxlen=60) - - def __get_player(self): - """Instanciate the player""" - host = self.config.get('MPD', 'host') - port = self.config.get('MPD', 'port') - pswd = self.config.get('MPD', 'password', fallback=None) - return PlayerClient(host, port, pswd) + self.changed = None def add_history(self): + """Handle local, in memory, short history""" self.short_history.appendleft(self.player.current) def register_plugin(self, plugin_class): - """Registers plubin in Sima instance...""" - self.plugins.append(plugin_class(self)) + """Registers plugin in Sima instance...""" + plgn = plugin_class(self) + prio = int(plgn.priority) + self._plugins.append((prio, plgn)) + + def register_core_plugin(self, plugin_class): + """Registers core plugins""" + plgn = plugin_class(self) + prio = int(plgn.priority) + self._core_plugins.append((prio, plgn)) def foreach_plugin(self, method, *args, **kwds): """Plugin's callbacks dispatcher""" + self.log.trace('dispatching %s to plugins', method) # pylint: disable=no-member + for plugin in self.core_plugins: + getattr(plugin, method)(*args, **kwds) for plugin in self.plugins: - #self.log.debug('dispatching {0} to {1}'.format(method, plugin)) getattr(plugin, method)(*args, **kwds) + @property + def core_plugins(self): + return [plugin[1] for plugin in + sorted(self._core_plugins, key=lambda pl: pl[0], reverse=True)] + + @property + def plugins(self): + return [plugin[1] for plugin in + sorted(self._plugins, key=lambda pl: pl[0], reverse=True)] + def need_tracks(self): + """Is the player in need for tracks""" if not self.enabled: self.log.debug('Queueing disabled!') return False - queue = self.player.queue queue_trigger = self.config.getint('sima', 'queue_length') - self.log.debug('Currently {0} track(s) ahead. (target {1})'.format( - len(queue), queue_trigger)) + if self.player.playmode.get('random'): + queue = self.player.playlist + self.log.debug('Currently %s track(s) in the playlist. (target %s)', len(queue), queue_trigger) + else: + queue = self.player.queue + self.log.debug('Currently %s track(s) ahead. (target %s)', len(queue), queue_trigger) if len(queue) < queue_trigger: return True return False @@ -74,15 +103,12 @@ class Sima(Daemon): def queue(self): to_add = list() for plugin in self.plugins: - pl_callback = getattr(plugin, 'callback_need_track')() - if pl_callback: - to_add.extend(pl_callback) - if not to_add: - self.log.warning('Queue plugins returned nothing!') - for plugin in self.plugins: - pl_callback = getattr(plugin, 'callback_need_track_fb')() - if pl_callback: - to_add.extend(pl_callback) + self.log.debug('callback_need_track: %s', plugin) + pl_candidates = getattr(plugin, 'callback_need_track')() + if pl_candidates: + to_add.extend(pl_candidates) + if to_add: + break for track in to_add: self.player.add(track) @@ -91,34 +117,41 @@ class Sima(Daemon): cycle : 5s 10s 1m 5m 20m 1h """ sleepfor = [5, 10, 60, 300, 1200, 3600] + # reset change + self.changed = None while True: tmp = sleepfor.pop(0) sleepfor.append(tmp) - self.log.info('Trying to reconnect in {:>4d} seconds'.format(tmp)) + self.log.info('Trying to reconnect in %4d seconds', tmp) time.sleep(tmp) try: self.player.connect() - except PlayerError: + except PlayerError as err: + self.log.debug(err) continue - except PlayerUnHandledError as err: - #TODO: unhandled Player exceptions - self.log.warning('Unhandled player exception: %s' % err) self.log.info('Got reconnected') break + self.foreach_plugin('start') def hup_handler(self, signum, frame): self.log.warning('Caught a sighup!') - self.player.disconnect() + # Cleaning pending command + self.player.clean() self.foreach_plugin('shutdown') + self.player.disconnect() raise SigHup('SIGHUP caught!') def shutdown(self): """General shutdown method """ self.log.warning('Starting shutdown.') - self.player.disconnect() - self.foreach_plugin('shutdown') - + # Cleaning pending command + try: + self.player.clean() + self.foreach_plugin('shutdown') + self.player.disconnect() + except PlayerError as err: + self.log.error('Player error during shutdown: %s', err) self.log.info('The way is shut, it was made by those who are dead. ' 'And the dead keep it…') self.log.info('bye...') @@ -126,39 +159,38 @@ class Sima(Daemon): def run(self): """ """ + try: + self.log.info('Connecting MPD: %(host)s:%(port)s', self.config['MPD']) + self.player.connect() + self.foreach_plugin('start') + except PlayerError as err: + self.log.warning('Player: %s', err) + self.reconnect_player() while 42: try: self.loop() - except PlayerUnHandledError as err: - #TODO: unhandled Player exceptions - self.log.warning('Unhandled player exception: {}'.format(err)) - del(self.player) - self.player = PlayerClient() - time.sleep(10) except PlayerError as err: - self.log.warning('Player error: %s' % err) + self.log.warning('Player error: %s', err) self.reconnect_player() - del(self.changed) def loop(self): """Dispatching callbacks to plugins """ - # hanging here untill a monitored event is raised in the player - if getattr(self, 'changed', False): # first iteration exception - self.changed = self.player.monitor() - else: # first iteration goes through else + # hanging here until a monitored event is raised in the player + if self.changed is None: # first iteration goes through else self.changed = ['playlist', 'player', 'skipped'] - self.log.debug('changed: {}'.format(', '.join(self.changed))) + else: # Wait for a change + self.changed = self.player.monitor() + self.log.debug('changed: %s', ', '.join(self.changed)) if 'playlist' in self.changed: self.foreach_plugin('callback_playlist') - if ('player' in self.changed - or 'options' in self.changed): + if 'player' in self.changed or 'options' in self.changed: self.foreach_plugin('callback_player') if 'database' in self.changed: self.foreach_plugin('callback_player_database') if 'skipped' in self.changed: if self.player.state == 'play': - self.log.info('Playing: {}'.format(self.player.current)) + self.log.info('Playing: %s', self.player.current) self.add_history() self.foreach_plugin('callback_next_song') if self.need_tracks():