140 lines
5.1 KiB
Python
140 lines
5.1 KiB
Python
# -*- coding: utf-8 -*-
|
|
from logging import getLogger
|
|
from threading import Thread
|
|
from Queue import Empty
|
|
|
|
from xbmc import sleep
|
|
|
|
from utils import ThreadMethods, window
|
|
from PlexFunctions import GetPlexMetadata, GetAllPlexChildren
|
|
import sync_info
|
|
import state
|
|
|
|
###############################################################################
|
|
|
|
log = getLogger("PLEX."+__name__)
|
|
|
|
###############################################################################
|
|
|
|
|
|
@ThreadMethods(add_stops=[state.SUSPEND_LIBRARY_THREAD])
|
|
class Threaded_Get_Metadata(Thread):
|
|
"""
|
|
Threaded download of Plex XML metadata for a certain library item.
|
|
Fills the out_queue with the downloaded etree XML objects
|
|
|
|
Input:
|
|
queue Queue.Queue() object that you'll need to fill up
|
|
with Plex itemIds
|
|
out_queue Queue() object where this thread will store
|
|
the downloaded metadata XMLs as etree objects
|
|
"""
|
|
def __init__(self, queue, out_queue):
|
|
self.queue = queue
|
|
self.out_queue = out_queue
|
|
Thread.__init__(self)
|
|
|
|
def terminate_now(self):
|
|
"""
|
|
Needed to terminate this thread, because there might be items left in
|
|
the queue which could cause other threads to hang
|
|
"""
|
|
while not self.queue.empty():
|
|
# Still try because remaining item might have been taken
|
|
try:
|
|
self.queue.get(block=False)
|
|
except Empty:
|
|
sleep(10)
|
|
continue
|
|
else:
|
|
self.queue.task_done()
|
|
if self.thread_stopped():
|
|
# Shutdown from outside requested; purge out_queue as well
|
|
while not self.out_queue.empty():
|
|
# Still try because remaining item might have been taken
|
|
try:
|
|
self.out_queue.get(block=False)
|
|
except Empty:
|
|
sleep(10)
|
|
continue
|
|
else:
|
|
self.out_queue.task_done()
|
|
|
|
def run(self):
|
|
"""
|
|
Catch all exceptions and log them
|
|
"""
|
|
try:
|
|
self.__run()
|
|
except Exception as e:
|
|
log.error('Exception %s' % e)
|
|
import traceback
|
|
log.error("Traceback:\n%s" % traceback.format_exc())
|
|
|
|
def __run(self):
|
|
"""
|
|
Do the work
|
|
"""
|
|
log.debug('Starting get metadata thread')
|
|
# cache local variables because it's faster
|
|
queue = self.queue
|
|
out_queue = self.out_queue
|
|
thread_stopped = self.thread_stopped
|
|
while thread_stopped() is False:
|
|
# grabs Plex item from queue
|
|
try:
|
|
item = queue.get(block=False)
|
|
# Empty queue
|
|
except Empty:
|
|
sleep(20)
|
|
continue
|
|
# Download Metadata
|
|
xml = GetPlexMetadata(item['itemId'])
|
|
if xml is None:
|
|
# Did not receive a valid XML - skip that item for now
|
|
log.error("Could not get metadata for %s. Skipping that item "
|
|
"for now" % item['itemId'])
|
|
# Increase BOTH counters - since metadata won't be processed
|
|
with sync_info.LOCK:
|
|
sync_info.GET_METADATA_COUNT += 1
|
|
sync_info.PROCESS_METADATA_COUNT += 1
|
|
queue.task_done()
|
|
continue
|
|
elif xml == 401:
|
|
log.error('HTTP 401 returned by PMS. Too much strain? '
|
|
'Cancelling sync for now')
|
|
window('plex_scancrashed', value='401')
|
|
# Kill remaining items in queue (for main thread to cont.)
|
|
queue.task_done()
|
|
break
|
|
|
|
item['XML'] = xml
|
|
if item.get('get_children') is True:
|
|
children_xml = GetAllPlexChildren(item['itemId'])
|
|
try:
|
|
children_xml[0].attrib
|
|
except (TypeError, IndexError, AttributeError):
|
|
log.error('Could not get children for Plex id %s'
|
|
% item['itemId'])
|
|
else:
|
|
item['children'] = []
|
|
for child in children_xml:
|
|
child_xml = GetPlexMetadata(child.attrib['ratingKey'])
|
|
try:
|
|
child_xml[0].attrib
|
|
except (TypeError, IndexError, AttributeError):
|
|
log.error('Could not get child for Plex id %s'
|
|
% child.attrib['ratingKey'])
|
|
else:
|
|
item['children'].append(child_xml[0])
|
|
|
|
# place item into out queue
|
|
out_queue.put(item)
|
|
# Keep track of where we are at
|
|
with sync_info.LOCK:
|
|
sync_info.GET_METADATA_COUNT += 1
|
|
# signals to queue job is done
|
|
queue.task_done()
|
|
# Empty queue in case PKC was shut down (main thread hangs otherwise)
|
|
self.terminate_now()
|
|
log.debug('Get metadata thread terminated')
|