Get through main loop in case of player reconnection

[mpd-sima.git] / sima / core.py

diff --git a/sima/core.py b/sima/core.py
index 3710d92f3ac03f991012bef8ec8377872b51d41e..694928fa77815ddd017aab71c4b2c9aadd2a4b78 100644 (file)
--- a/sima/core.py
+++ b/sima/core.py
@@ -1,37 +1,52 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """Core Object dealing with plugins and player client
 """
 
-__version__ = '0.12.0.b'
+__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, Track
+from .client import PlayerClient
 from .client import PlayerError, PlayerUnHandledError
 from .lib.simadb import SimaDB
+from .lib.daemon import Daemon
 
-class Sima(object):
+class Sima(Daemon):
     """Main class, plugin and player management
     """
 
-    def __init__(self, conf, dbfile):
+    def __init__(self, conf):
+        ## Set daemon
+        Daemon.__init__(self, conf.get('daemon', 'pidfile'))
+        self.enabled = True
         self.config = conf
-        self.sdb = SimaDB(db_path=dbfile)
+        self.sdb = SimaDB(db_path=conf.get('sima', 'db_file'))
+        PlayerClient.database = self.sdb
         self.log = getLogger('sima')
         self.plugins = list()
-        self.player = PlayerClient()  # Player client
+        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.current_track = None
+        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)
+
+    def add_history(self):
+        self.short_history.appendleft(self.player.current)
 
     def register_plugin(self, plugin_class):
         """Registers plubin in Sima instance..."""
@@ -40,8 +55,36 @@ class Sima(object):
     def foreach_plugin(self, method, *args, **kwds):
         """Plugin's callbacks dispatcher"""
         for plugin in self.plugins:
+            #self.log.debug('dispatching {0} to {1}'.format(method, plugin))
             getattr(plugin, method)(*args, **kwds)
 
+    def need_tracks(self):
+        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 len(queue) < queue_trigger:
+            return True
+        return False
+
+    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)
+        for track in to_add:
+            self.player.add(track)
+
     def reconnect_player(self):
         """Trying to reconnect cycling through longer timeout
         cycle : 5s 10s 1m 5m 20m 1h
@@ -72,12 +115,10 @@ class Sima(object):
         self.log.info('The way is shut, it was made by those who are dead. '
                       'And the dead keep it…')
         self.log.info('bye...')
-        sys.exit(0)
 
     def run(self):
         """
         """
-        self.current_track = Track()
         while 42:
             try:
                 self.loop()
@@ -90,26 +131,31 @@ class Sima(object):
             except PlayerError as 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 loop detection
+        if getattr(self, 'changed', False): # first iteration exception
             self.changed = self.player.monitor()
-        else:
+        else:  # first iteration goes through else
             self.changed = ['playlist', 'player', 'skipped']
         self.log.debug('changed: {}'.format(', '.join(self.changed)))
         if 'playlist' in self.changed:
             self.foreach_plugin('callback_playlist')
-        if 'player' 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.add_history()
                 self.foreach_plugin('callback_next_song')
-                self.current_track = self.player.current
-
+        if self.need_tracks():
+            self.queue()
 
 # VIM MODLINE
 # vim: ai ts=4 sw=4 sts=4 expandtab