PlexKodiConnect/resources/lib/webservice.py

# -*- coding: utf-8 -*-
'''
PKC-dedicated webserver. Listens to Kodi starting playback; will then hand-over
playback to plugin://video.plexkodiconnect
'''
from __future__ import absolute_import, division, unicode_literals
from logging import getLogger
import BaseHTTPServer
import httplib
import socket
import Queue

import xbmc
import xbmcvfs

from .plex_api import API
from .plex_db import PlexDB
from . import backgroundthread, utils, variables as v, app, playqueue as PQ
from . import json_rpc as js, plex_functions as PF


LOG = getLogger('PLEX.webservice')


class WebService(backgroundthread.KillableThread):
    ''' Run a webservice to trigger playback.
    '''
    def is_alive(self):
        ''' Called to see if the webservice is still responding.
        '''
        alive = True
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect(('127.0.0.1', v.WEBSERVICE_PORT))
            s.sendall('')
        except Exception as error:
            LOG.error('is_alive error: %s', error)
            if 'Errno 61' in str(error):
                alive = False
        s.close()
        return alive

    def abort(self):
        ''' Called when the thread needs to stop
        '''
        try:
            conn = httplib.HTTPConnection('127.0.0.1:%d' % v.WEBSERVICE_PORT)
            conn.request('QUIT', '/')
            conn.getresponse()
        except Exception as error:
            xbmc.log('PLEX.webservice abort error: %s' % error, xbmc.LOGWARNING)

    def suspend(self):
        """
        Called when thread needs to suspend - let's not do anything and keep
        webservice up
        """
        self.suspend_reached = True

    def resume(self):
        """
        Called when thread needs to resume - let's not do anything and keep
        webservice up
        """
        self.suspend_reached = False

    def run(self):
        ''' Called to start the webservice.
        '''
        LOG.info('----===## Starting WebService on port %s ##===----',
                 v.WEBSERVICE_PORT)
        app.APP.register_thread(self)
        try:
            server = HttpServer(('127.0.0.1', v.WEBSERVICE_PORT),
                                RequestHandler)
            LOG.info('Serving http on %s', server.socket.getsockname())
            server.serve_forever()
        except Exception as error:
            LOG.error('Error encountered: %s', error)
            if '10053' not in error:  # ignore host diconnected errors
                utils.ERROR()
        finally:
            app.APP.deregister_thread(self)
            LOG.info('##===---- WebService stopped ----===##')


class HttpServer(BaseHTTPServer.HTTPServer):
    ''' Http server that reacts to self.stop flag.
    '''
    def __init__(self, *args, **kwargs):
        self.stop = False
        self.pending = []
        self.threads = []
        self.queue = Queue.Queue()
        BaseHTTPServer.HTTPServer.__init__(self, *args, **kwargs)

    def serve_forever(self):

        ''' Handle one request at a time until stopped.
        '''
        while not self.stop:
            self.handle_request()


class RequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
    '''
    Http request handler. Do not use LOG here, it will hang requests in Kodi >
    show information dialog.
    '''
    timeout = 0.5

    def log_message(self, format, *args):
        ''' Mute the webservice requests.
        '''
        pass

    def handle(self):
        ''' To quiet socket errors with 404.
        '''
        try:
            BaseHTTPServer.BaseHTTPRequestHandler.handle(self)
        except Exception as error:
            if '10054' in error:
                # Silence "[Errno 10054] An existing connection was forcibly
                # closed by the remote host"
                return
            xbmc.log('PLEX.webservice handle error: %s' % error, xbmc.LOGWARNING)

    def do_QUIT(self):
        ''' send 200 OK response, and set server.stop to True
        '''
        self.send_response(200)
        self.end_headers()
        self.server.stop = True

    def get_params(self):
        ''' Get the params as a dict
        '''
        try:
            path = self.path[1:].decode('utf-8')
        except IndexError:
            path = ''
            params = {}
        if '?' in path:
            path = path.split('?', 1)[1]
        params = dict(utils.parse_qsl(path))
        if 'plex_id' not in params:
            LOG.error('No plex_id received for path %s', path)
            return

        if 'plex_type' in params and params['plex_type'].lower() == 'none':
            del params['plex_type']
        if 'plex_type' not in params:
            LOG.debug('Need to look-up plex_type')
            with PlexDB(lock=False) as plexdb:
                db_item = plexdb.item_by_id(params['plex_id'])
            if db_item:
                params['plex_type'] = db_item['plex_type']
            else:
                LOG.debug('No plex_type found, using Kodi player id')
                players = js.get_players()
                if players:
                    params['plex_type'] = v.PLEX_TYPE_CLIP if 'video' in players \
                        else v.PLEX_TYPE_SONG
                    LOG.debug('Using the following plex_type: %s',
                              params['plex_type'])
                else:
                    xml = PF.GetPlexMetadata(params['plex_id'])
                    if xml in (None, 401):
                        LOG.error('Could not get metadata for %s', params)
                        return
                    api = API(xml[0])
                    params['plex_type'] = api.plex_type()
                    LOG.debug('Got metadata, using plex_type %s',
                              params['plex_type'])
        return params

    def do_HEAD(self):
        ''' Called on HEAD requests
        '''
        self.handle_request(True)

    def do_GET(self):
        ''' Called on GET requests
        '''
        self.handle_request()

    def handle_request(self, headers_only=False):
        '''Send headers and reponse
        '''
        xbmc.log('PLEX.webservice handle_request called. headers %s, path: %s'
                 % (headers_only, self.path), xbmc.LOGDEBUG)
        try:
            if b'extrafanart' in self.path or b'extrathumbs' in self.path:
                raise Exception('unsupported artwork request')

            if headers_only:
                self.send_response(200)
                self.send_header(b'Content-type', b'text/html')
                self.end_headers()

            elif b'file.strm' not in self.path:
                self.images()
            else:
                self.strm()

        except Exception as error:
            self.send_error(500,
                            b'PLEX.webservice: Exception occurred: %s' % error)

    def strm(self):
        ''' Return a dummy video and and queue real items.
        '''
        xbmc.log('PLEX.webservice: starting strm', xbmc.LOGDEBUG)
        self.send_response(200)
        self.send_header(b'Content-type', b'text/html')
        self.end_headers()

        params = self.get_params()

        if b'kodi/movies' in self.path:
            params['kodi_type'] = v.KODI_TYPE_MOVIE
        elif b'kodi/tvshows' in self.path:
            params['kodi_type'] = v.KODI_TYPE_EPISODE
        # elif 'kodi/musicvideos' in self.path:
        #     params['MediaType'] = 'musicvideo'

        if utils.settings('pluginSingle.bool'):
            path = 'plugin://plugin.video.plexkodiconnect?mode=playsingle&plex_id=%s' % params['plex_id']
            if params.get('server'):
                path += '&server=%s' % params['server']
            if params.get('transcode'):
                path += '&transcode=true'
            if params.get('kodi_id'):
                path += '&kodi_id=%s' % params['kodi_id']
            if params.get('kodi_type'):
                path += '&kodi_type=%s' % params['kodi_type']
            self.wfile.write(bytes(path))
            return

        path = 'plugin://plugin.video.plexkodiconnect?mode=playstrm&plex_id=%s' % params['plex_id']
        self.wfile.write(bytes(path.encode('utf-8')))
        if params['plex_id'] not in self.server.pending:
            self.server.pending.append(params['plex_id'])
            self.server.queue.put(params)
            if not len(self.server.threads):
                queue = QueuePlay(self.server, params['plex_type'])
                queue.start()
                self.server.threads.append(queue)

    def images(self):
        ''' Return a dummy image for unwanted images requests over the webservice.
            Required to prevent freezing of widget playback if the file url has no
            local textures cached yet.
        '''
        image = xbmc.translatePath(
            'special://home/addons/plugin.video.plexkodiconnect/icon.png').decode('utf-8')
        self.send_response(200)
        self.send_header(b'Content-type', b'image/png')
        modified = xbmcvfs.Stat(image).st_mtime()
        self.send_header(b'Last-Modified', b'%s' % modified)
        image = xbmcvfs.File(image)
        size = image.size()
        self.send_header(b'Content-Length', str(size))
        self.end_headers()
        self.wfile.write(image.readBytes())
        image.close()


class QueuePlay(backgroundthread.KillableThread):
    ''' Workflow for new playback:

        Queue up strm playback that was called in the webservice. Called
        playstrm in default.py which will wait for our signal here. Downloads
        plex information. Add content to the playlist after the strm file that
        initiated playback from db. Start playback by telling playstrm waiting.
        It will fail playback of the current strm and move to the next entry for
        us. If play folder, playback starts here.

        Required delay for widgets, custom skin containers and non library
        windows. Otherwise Kodi will freeze if no artwork textures are cached
        yet in Textures13.db Will be skipped if the player already has media and
        is playing.

        Why do all this instead of using plugin? Strms behaves better than
        plugin in database. Allows to load chapter images with direct play.
        Allows to have proper artwork for intros. Faster than resolving using
        plugin, especially on low powered devices. Cons: Can't use external
        players with this method.
    '''

    def __init__(self, server, plex_type):
        self.server = server
        self.plex_type = plex_type
        self.plex_id = None
        self.kodi_id = None
        self.kodi_type = None
        self.synched = True
        self.force_transcode = False
        super(QueuePlay, self).__init__()

    def load_params(self, params):
        self.plex_id = utils.cast(int, params['plex_id'])
        self.plex_type = params.get('plex_type')
        self.kodi_id = utils.cast(int, params.get('kodi_id'))
        self.kodi_type = params.get('kodi_type')
        # Some cleanup
        if params.get('transcode'):
            self.force_transcode = params['transcode'].lower() == 'true'
        if params.get('server') and params['server'].lower() == 'none':
            self.server = None
        if params.get('synched'):
            self.synched = not params['synched'].lower() == 'false'

    def _get_playqueue(self):
        playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_VIDEO)
        if ((self.plex_type in v.PLEX_VIDEOTYPES and
             not app.PLAYSTATE.initiated_by_plex and
             xbmc.getCondVisibility('Window.IsVisible(Home.xml)'))):
            # Video launched from a widget - which starts a Kodi AUDIO playlist
            # We will empty everything and start with a fresh VIDEO playlist
            LOG.debug('Widget video playback detected')
            video_widget_playback = True
            # Release default.py
            utils.window('plex.playlist.play', value='true')
            # The playlist will be ready anyway
            app.PLAYSTATE.playlist_ready = True
            playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_AUDIO)
            playqueue.clear()
            playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_VIDEO)
            playqueue.clear()
            # Wait for Kodi to catch up - xbmcplugin.setResolvedUrl() needs to
            # have run its course and thus the original item needs to have
            # failed before we start playback anew
            xbmc.sleep(200)
        else:
            video_widget_playback = False
            if self.plex_type in v.PLEX_VIDEOTYPES:
                LOG.debug('Video playback detected')
                playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_VIDEO)
            else:
                LOG.debug('Audio playback detected')
                playqueue = PQ.get_playqueue_from_type(v.KODI_TYPE_AUDIO)
        return playqueue, video_widget_playback

    def run(self):
        with app.APP.lock_playqueues:
            LOG.debug('##===---- Starting QueuePlay ----===##')
            try:
                self._run()
            finally:
                app.PLAYSTATE.playlist_ready = False
                app.PLAYSTATE.playlist_start_pos = None
                app.PLAYSTATE.initiated_by_plex = False
                self.server.threads.remove(self)
                self.server.pending = []
                LOG.debug('##===---- QueuePlay Stopped ----===##')

    def _run(self):
        abort = False
        play_folder = False
        playqueue, video_widget_playback = self._get_playqueue()
        # Position to start playback from (!!)
        # Do NOT use kodi_pl.getposition() as that appears to be buggy
        try:
            start_position = max(js.get_position(playqueue.playlistid), 0)
        except KeyError:
            # Widgets: Since we've emptied the entire playlist, we won't get a
            # position
            start_position = 0
        # Position to add next element to queue - we're doing this at the end
        # of our current playqueue
        position = playqueue.kodi_pl.size()
        # Set to start_position + 1 because first item will fail
        app.PLAYSTATE.playlist_start_pos = start_position + 1
        LOG.debug('start_position %s, position %s for current playqueue: %s',
                  start_position, position, playqueue)
        while True:
            try:
                try:
                    # We cannot know when Kodi will send the last item, e.g.
                    # when playing an entire folder
                    params = self.server.queue.get(timeout=0.01)
                except Queue.Empty:
                    LOG.debug('Wrapping up')
                    if xbmc.getCondVisibility('VideoPlayer.Content(livetv)'):
                        # avoid issues with ongoing Live TV playback
                        app.APP.player.stop()
                    count = 50
                    while not app.PLAYSTATE.playlist_ready:
                        xbmc.sleep(50)
                        if not count:
                            LOG.info('Playback aborted')
                            raise Exception('Playback aborted')
                        count -= 1
                    if play_folder:
                        LOG.info('Start playing folder')
                        xbmc.executebuiltin('Dialog.Close(busydialognocancel)')
                        playqueue.start_playback(start_position)
                    elif video_widget_playback:
                        LOG.info('Start widget video playback')
                        playqueue.start_playback()
                    else:
                        LOG.info('Start normal playback')
                        # Release default.py
                        utils.window('plex.playlist.play', value='true')
                        if not app.PLAYSTATE.initiated_by_plex:
                            # Remove the playlist element we just added with the
                            # right path
                            xbmc.sleep(1000)
                            playqueue.kodi_remove_item(start_position)
                            del playqueue.items[start_position]
                    LOG.debug('Done wrapping up')
                    break
                self.load_params(params)
                if play_folder:
                    playlistitem = PQ.PlaylistItem(plex_id=self.plex_id,
                                                   plex_type=self.plex_type,
                                                   kodi_id=self.kodi_id,
                                                   kodi_type=self.kodi_type)
                    playlistitem.force_transcode = self.force_transcode
                    playqueue.add_item(playlistitem, position)
                    position += 1
                else:
                    if self.server.pending.count(params['plex_id']) != len(self.server.pending):
                        # E.g. when selecting "play" for an entire video genre
                        LOG.debug('Folder playback detected')
                        play_folder = True
                        xbmc.executebuiltin('Activateutils.window(busydialognocancel)')
                    playqueue.play(self.plex_id,
                                   plex_type=self.plex_type,
                                   startpos=start_position,
                                   position=position,
                                   synched=self.synched,
                                   force_transcode=self.force_transcode)
                    # Do NOT start playback here - because Kodi already started
                    # it!
                    position = playqueue.index
            except Exception:
                abort = True
                utils.ERROR(notify=True)
            try:
                self.server.queue.task_done()
            except ValueError:
                # "task_done() called too many times" when aborting
                pass
            if abort:
                app.APP.player.stop()
                playqueue.clear()
                self.server.queue.queue.clear()
                if play_folder:
                    xbmc.executebuiltin('Dialog.Close(busydialognocancel)')
                else:
                    utils.window('plex.playlist.aborted', value='true')
                break