1683 lines
69 KiB
Python
1683 lines
69 KiB
Python
# -*- coding: utf-8 -*-
|
|
###############################################################################
|
|
from logging import getLogger
|
|
from threading import Thread
|
|
import Queue
|
|
from random import shuffle
|
|
import copy
|
|
|
|
import xbmc
|
|
from xbmcvfs import exists
|
|
|
|
import utils
|
|
from utils import window, settings, dialog, language as lang, try_decode, \
|
|
try_encode
|
|
from downloadutils import DownloadUtils as DU
|
|
import itemtypes
|
|
import plexdb_functions as plexdb
|
|
import kodidb_functions as kodidb
|
|
import artwork
|
|
import videonodes
|
|
import variables as v
|
|
|
|
import PlexFunctions as PF
|
|
import PlexAPI
|
|
from library_sync.get_metadata import ThreadedGetMetadata
|
|
from library_sync.process_metadata import ThreadedProcessMetadata
|
|
import library_sync.sync_info as sync_info
|
|
from library_sync.fanart import ThreadedProcessFanart
|
|
import music
|
|
import playlists
|
|
import state
|
|
|
|
###############################################################################
|
|
|
|
LOG = getLogger("PLEX." + __name__)
|
|
|
|
###############################################################################
|
|
|
|
|
|
@utils.thread_methods(add_suspends=['SUSPEND_LIBRARY_THREAD', 'STOP_SYNC'])
|
|
class LibrarySync(Thread):
|
|
"""
|
|
The one and only library sync thread. Spawn only 1!
|
|
"""
|
|
def __init__(self):
|
|
self.items_to_process = []
|
|
self.views = []
|
|
self.session_keys = {}
|
|
self.fanartqueue = Queue.Queue()
|
|
self.fanartthread = ThreadedProcessFanart(self.fanartqueue)
|
|
# How long should we wait at least to process new/changed PMS items?
|
|
self.vnodes = videonodes.VideoNodes()
|
|
self.install_sync_done = settings('SyncInstallRunDone') == 'true'
|
|
# Show sync dialog even if user deactivated?
|
|
self.force_dialog = True
|
|
# Need to be set accordingly later
|
|
self.compare = None
|
|
self.new_items_only = None
|
|
self.update_kodi_video_library = None
|
|
self.update_kodi_music_library = None
|
|
self.nodes = {}
|
|
self.playlists = {}
|
|
self.sorted_views = []
|
|
self.old_views = []
|
|
self.updatelist = []
|
|
self.all_plex_ids = {}
|
|
self.all_kodi_ids = {}
|
|
Thread.__init__(self)
|
|
|
|
def suspend_item_sync(self):
|
|
"""
|
|
Returns True if we should not sync new items or artwork to Kodi or even
|
|
abort a sync currently running.
|
|
|
|
Returns False otherwise.
|
|
"""
|
|
if self.suspended() or self.stopped():
|
|
return True
|
|
elif state.SUSPEND_SYNC:
|
|
return True
|
|
return False
|
|
|
|
def show_kodi_note(self, message, icon="plex"):
|
|
"""
|
|
Shows a Kodi popup, if user selected to do so. Pass message in unicode
|
|
or string
|
|
|
|
icon: "plex": shows Plex icon
|
|
"error": shows Kodi error icon
|
|
"""
|
|
if state.SYNC_DIALOG is not True and self.force_dialog is not True:
|
|
return
|
|
if icon == "plex":
|
|
dialog('notification',
|
|
heading='{plex}',
|
|
message=message,
|
|
icon='{plex}',
|
|
sound=False)
|
|
elif icon == "error":
|
|
dialog('notification',
|
|
heading='{plex}',
|
|
message=message,
|
|
icon='{error}')
|
|
|
|
@staticmethod
|
|
def sync_pms_time():
|
|
"""
|
|
PMS does not provide a means to get a server timestamp. This is a work-
|
|
around.
|
|
|
|
In general, everything saved to Kodi shall be in Kodi time.
|
|
|
|
Any info with a PMS timestamp is in Plex time, naturally
|
|
"""
|
|
LOG.info('Synching time with PMS server')
|
|
# Find a PMS item where we can toggle the view state to enforce a
|
|
# change in lastViewedAt
|
|
|
|
# Get all Plex libraries
|
|
sections = PF.get_plex_sections()
|
|
try:
|
|
sections.attrib
|
|
except AttributeError:
|
|
LOG.error("Error download PMS views, abort sync_pms_time")
|
|
return False
|
|
|
|
plex_id = None
|
|
for mediatype in (v.PLEX_TYPE_MOVIE,
|
|
v.PLEX_TYPE_SHOW,
|
|
v.PLEX_TYPE_ARTIST):
|
|
if plex_id is not None:
|
|
break
|
|
for view in sections:
|
|
if plex_id is not None:
|
|
break
|
|
if not view.attrib['type'] == mediatype:
|
|
continue
|
|
library_id = view.attrib['key']
|
|
items = PF.GetAllPlexLeaves(library_id)
|
|
if items in (None, 401):
|
|
LOG.error("Could not download section %s",
|
|
view.attrib['key'])
|
|
continue
|
|
for item in items:
|
|
if item.attrib.get('viewCount') is not None:
|
|
# Don't want to mess with items that have playcount>0
|
|
continue
|
|
if item.attrib.get('viewOffset') is not None:
|
|
# Don't mess with items with a resume point
|
|
continue
|
|
plex_id = item.attrib.get('ratingKey')
|
|
LOG.info('Found an item to sync with: %s', plex_id)
|
|
break
|
|
|
|
if plex_id is None:
|
|
LOG.error("Could not find an item to sync time with")
|
|
LOG.error("Aborting PMS-Kodi time sync")
|
|
return False
|
|
|
|
# Get the Plex item's metadata
|
|
xml = PF.GetPlexMetadata(plex_id)
|
|
if xml in (None, 401):
|
|
LOG.error("Could not download metadata, aborting time sync")
|
|
return False
|
|
|
|
timestamp = xml[0].attrib.get('lastViewedAt')
|
|
if timestamp is None:
|
|
timestamp = xml[0].attrib.get('updatedAt')
|
|
LOG.debug('Using items updatedAt=%s', timestamp)
|
|
if timestamp is None:
|
|
timestamp = xml[0].attrib.get('addedAt')
|
|
LOG.debug('Using items addedAt=%s', timestamp)
|
|
if timestamp is None:
|
|
timestamp = 0
|
|
LOG.debug('No timestamp; using 0')
|
|
|
|
# Set the timer
|
|
koditime = utils.unix_timestamp()
|
|
# Toggle watched state
|
|
PF.scrobble(plex_id, 'watched')
|
|
# Let the PMS process this first!
|
|
xbmc.sleep(1000)
|
|
# Get PMS items to find the item we just changed
|
|
items = PF.GetAllPlexLeaves(library_id, lastViewedAt=timestamp)
|
|
# Toggle watched state back
|
|
PF.scrobble(plex_id, 'unwatched')
|
|
if items in (None, 401):
|
|
LOG.error("Could not download metadata, aborting time sync")
|
|
return False
|
|
|
|
plextime = None
|
|
for item in items:
|
|
if item.attrib['ratingKey'] == plex_id:
|
|
plextime = item.attrib.get('lastViewedAt')
|
|
break
|
|
|
|
if plextime is None:
|
|
LOG.error('Could not get lastViewedAt - aborting')
|
|
return False
|
|
|
|
# Calculate time offset Kodi-PMS
|
|
state.KODI_PLEX_TIME_OFFSET = float(koditime) - float(plextime)
|
|
settings('kodiplextimeoffset', value=str(state.KODI_PLEX_TIME_OFFSET))
|
|
LOG.info("Time offset Koditime - Plextime in seconds: %s",
|
|
str(state.KODI_PLEX_TIME_OFFSET))
|
|
return True
|
|
|
|
@staticmethod
|
|
def initialize_plex_db():
|
|
"""
|
|
Run once during startup to verify that plex db exists.
|
|
"""
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
# Create the tables for the plex database
|
|
plex_db.plexcursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS plex(
|
|
plex_id TEXT UNIQUE,
|
|
view_id TEXT,
|
|
plex_type TEXT,
|
|
kodi_type TEXT,
|
|
kodi_id INTEGER,
|
|
kodi_fileid INTEGER,
|
|
kodi_pathid INTEGER,
|
|
parent_id INTEGER,
|
|
checksum INTEGER,
|
|
fanart_synced INTEGER)
|
|
''')
|
|
plex_db.plexcursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS view(
|
|
view_id TEXT UNIQUE,
|
|
view_name TEXT,
|
|
kodi_type TEXT,
|
|
kodi_tagid INTEGER,
|
|
sync_to_kodi INTEGER)
|
|
''')
|
|
plex_db.plexcursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS version(idVersion TEXT)
|
|
''')
|
|
plex_db.plexcursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS playlists(
|
|
plex_id TEXT UNIQUE,
|
|
plex_name TEXT,
|
|
plex_updatedat TEXT,
|
|
kodi_path TEXT,
|
|
kodi_type TEXT,
|
|
kodi_hash TEXT)
|
|
''')
|
|
# Create an index for actors to speed up sync
|
|
utils.create_actor_db_index()
|
|
|
|
@utils.log_time
|
|
def full_sync(self, repair=False):
|
|
"""
|
|
repair=True: force sync EVERY item
|
|
"""
|
|
# Reset our keys
|
|
self.session_keys = {}
|
|
# self.compare == False: we're syncing EVERY item
|
|
# True: we're syncing only the delta, e.g. different checksum
|
|
self.compare = not repair
|
|
|
|
self.new_items_only = True
|
|
# This will also update playstates and userratings!
|
|
LOG.info('Running fullsync for NEW PMS items with repair=%s', repair)
|
|
if self._full_sync() is False:
|
|
return False
|
|
self.new_items_only = False
|
|
# This will NOT update playstates and userratings!
|
|
LOG.info('Running fullsync for CHANGED PMS items with repair=%s',
|
|
repair)
|
|
if self._full_sync() is False:
|
|
return False
|
|
return True
|
|
|
|
def _full_sync(self):
|
|
process = {
|
|
'movies': self.plex_movies,
|
|
'tvshows': self.plex_tv_show,
|
|
}
|
|
if state.ENABLE_MUSIC:
|
|
process['music'] = self.plex_music
|
|
|
|
# Do the processing
|
|
for itemtype in process:
|
|
if self.suspend_item_sync() or not process[itemtype]():
|
|
return False
|
|
|
|
# Let kodi update the views in any case, since we're doing a full sync
|
|
xbmc.executebuiltin('UpdateLibrary(video)')
|
|
if state.ENABLE_MUSIC:
|
|
xbmc.executebuiltin('UpdateLibrary(music)')
|
|
|
|
if window('plex_scancrashed') == 'true':
|
|
# Show warning if itemtypes.py crashed at some point
|
|
dialog('ok', heading='{plex}', line1=lang(39408))
|
|
window('plex_scancrashed', clear=True)
|
|
elif window('plex_scancrashed') == '401':
|
|
window('plex_scancrashed', clear=True)
|
|
if state.PMS_STATUS not in ('401', 'Auth'):
|
|
# Plex server had too much and returned ERROR
|
|
dialog('ok', heading='{plex}', line1=lang(39409))
|
|
return True
|
|
|
|
def _process_view(self, folder_item, kodi_db, plex_db, totalnodes):
|
|
vnodes = self.vnodes
|
|
folder = folder_item.attrib
|
|
mediatype = folder['type']
|
|
# Only process supported formats
|
|
if mediatype not in (v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW,
|
|
v.PLEX_TYPE_ARTIST, v.PLEX_TYPE_PHOTO):
|
|
return totalnodes
|
|
|
|
# Prevent duplicate for nodes of the same type
|
|
nodes = self.nodes[mediatype]
|
|
# Prevent duplicate for playlists of the same type
|
|
lists = self.playlists[mediatype]
|
|
sorted_views = self.sorted_views
|
|
|
|
folderid = folder['key']
|
|
foldername = folder['title']
|
|
viewtype = folder['type']
|
|
|
|
# Get current media folders from plex database
|
|
view = plex_db.getView_byId(folderid)
|
|
try:
|
|
current_viewname = view[0]
|
|
current_viewtype = view[1]
|
|
current_tagid = view[2]
|
|
except TypeError:
|
|
LOG.info('Creating viewid: %s in Plex database.', folderid)
|
|
tagid = kodi_db.createTag(foldername)
|
|
# Create playlist for the video library
|
|
if (foldername not in lists and
|
|
mediatype in (v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW)):
|
|
utils.playlist_xsp(mediatype, foldername, folderid, viewtype)
|
|
lists.append(foldername)
|
|
# Create the video node
|
|
if (foldername not in nodes and
|
|
mediatype != v.PLEX_TYPE_ARTIST):
|
|
vnodes.viewNode(sorted_views.index(foldername),
|
|
foldername,
|
|
mediatype,
|
|
viewtype,
|
|
folderid)
|
|
nodes.append(foldername)
|
|
totalnodes += 1
|
|
# Add view to plex database
|
|
plex_db.addView(folderid, foldername, viewtype, tagid)
|
|
else:
|
|
LOG.info(' '.join((
|
|
'Found viewid: %s' % folderid,
|
|
'viewname: %s' % current_viewname,
|
|
'viewtype: %s' % current_viewtype,
|
|
'tagid: %s' % current_tagid)))
|
|
|
|
# Remove views that are still valid to delete rest later
|
|
try:
|
|
self.old_views.remove(folderid)
|
|
except ValueError:
|
|
# View was just created, nothing to remove
|
|
pass
|
|
|
|
# View was modified, update with latest info
|
|
if current_viewname != foldername:
|
|
LOG.info('viewid: %s new viewname: %s', folderid, foldername)
|
|
tagid = kodi_db.createTag(foldername)
|
|
|
|
# Update view with new info
|
|
plex_db.updateView(foldername, tagid, folderid)
|
|
|
|
if mediatype != "artist":
|
|
if plex_db.getView_byName(current_viewname) is None:
|
|
# The tag could be a combined view. Ensure there's
|
|
# no other tags with the same name before deleting
|
|
# playlist.
|
|
utils.playlist_xsp(mediatype,
|
|
current_viewname,
|
|
folderid,
|
|
current_viewtype,
|
|
True)
|
|
# Delete video node
|
|
if mediatype != "musicvideos":
|
|
vnodes.viewNode(
|
|
indexnumber=sorted_views.index(foldername),
|
|
tagname=current_viewname,
|
|
mediatype=mediatype,
|
|
viewtype=current_viewtype,
|
|
viewid=folderid,
|
|
delete=True)
|
|
# Added new playlist
|
|
if (foldername not in lists and mediatype in
|
|
(v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW)):
|
|
utils.playlist_xsp(mediatype,
|
|
foldername,
|
|
folderid,
|
|
viewtype)
|
|
lists.append(foldername)
|
|
# Add new video node
|
|
if foldername not in nodes and mediatype != "musicvideos":
|
|
vnodes.viewNode(sorted_views.index(foldername),
|
|
foldername,
|
|
mediatype,
|
|
viewtype,
|
|
folderid)
|
|
nodes.append(foldername)
|
|
totalnodes += 1
|
|
|
|
# Update items with new tag
|
|
items = plex_db.getItem_byView(folderid)
|
|
for item in items:
|
|
# Remove the "s" from viewtype for tags
|
|
kodi_db.updateTag(
|
|
current_tagid, tagid, item[0], current_viewtype[:-1])
|
|
else:
|
|
# Validate the playlist exists or recreate it
|
|
if mediatype != v.PLEX_TYPE_ARTIST:
|
|
if (foldername not in lists and mediatype in
|
|
(v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW)):
|
|
utils.playlist_xsp(mediatype,
|
|
foldername,
|
|
folderid,
|
|
viewtype)
|
|
lists.append(foldername)
|
|
# Create the video node if not already exists
|
|
if foldername not in nodes and mediatype != "musicvideos":
|
|
vnodes.viewNode(sorted_views.index(foldername),
|
|
foldername,
|
|
mediatype,
|
|
viewtype,
|
|
folderid)
|
|
nodes.append(foldername)
|
|
totalnodes += 1
|
|
return totalnodes
|
|
|
|
def maintain_views(self):
|
|
"""
|
|
Compare the views to Plex
|
|
"""
|
|
if state.DIRECT_PATHS is True and state.ENABLE_MUSIC is True:
|
|
# Will reboot Kodi is new library detected
|
|
music.excludefromscan_music_folders()
|
|
|
|
self.views = []
|
|
vnodes = self.vnodes
|
|
|
|
# Get views
|
|
sections = PF.get_plex_sections()
|
|
try:
|
|
sections.attrib
|
|
except AttributeError:
|
|
LOG.error("Error download PMS views, abort maintain_views")
|
|
return False
|
|
|
|
self.nodes = {
|
|
v.PLEX_TYPE_MOVIE: [],
|
|
v.PLEX_TYPE_SHOW: [],
|
|
v.PLEX_TYPE_ARTIST: [],
|
|
v.PLEX_TYPE_PHOTO: []
|
|
}
|
|
self.playlists = copy.deepcopy(self.nodes)
|
|
self.sorted_views = []
|
|
|
|
for view in sections:
|
|
if (view.attrib['type'] in
|
|
(v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW, v.PLEX_TYPE_PHOTO)):
|
|
self.sorted_views.append(view.attrib['title'])
|
|
LOG.debug('Sorted views: %s', self.sorted_views)
|
|
|
|
# total nodes for window properties
|
|
vnodes.clearProperties()
|
|
totalnodes = len(self.sorted_views)
|
|
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
# Backup old views to delete them later, if needed (at the end
|
|
# of this method, only unused views will be left in oldviews)
|
|
self.old_views = plex_db.getViews()
|
|
with kodidb.GetKodiDB('video') as kodi_db:
|
|
for folder_item in sections:
|
|
totalnodes = self._process_view(folder_item,
|
|
kodi_db,
|
|
plex_db,
|
|
totalnodes)
|
|
# Add video nodes listings
|
|
# Plex: there seem to be no favorites/favorites tag
|
|
# vnodes.singleNode(totalnodes,
|
|
# "Favorite movies",
|
|
# "movies",
|
|
# "favourites")
|
|
# totalnodes += 1
|
|
# vnodes.singleNode(totalnodes,
|
|
# "Favorite tvshows",
|
|
# "tvshows",
|
|
# "favourites")
|
|
# totalnodes += 1
|
|
# vnodes.singleNode(totalnodes,
|
|
# "channels",
|
|
# "movies",
|
|
# "channels")
|
|
# totalnodes += 1
|
|
|
|
# Save total
|
|
window('Plex.nodes.total', str(totalnodes))
|
|
|
|
# Get rid of old items (view has been deleted on Plex side)
|
|
if self.old_views:
|
|
self.delete_views()
|
|
# update views for all:
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
self.views = plex_db.getAllViewInfo()
|
|
LOG.info("Finished processing views. Views saved: %s", self.views)
|
|
return True
|
|
|
|
def delete_views(self):
|
|
LOG.info("Removing views: %s", self.old_views)
|
|
delete_items = []
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
for view in self.old_views:
|
|
plex_db.removeView(view)
|
|
delete_items.extend(plex_db.get_items_by_viewid(view))
|
|
delete_movies = []
|
|
delete_tv = []
|
|
delete_music = []
|
|
for item in delete_items:
|
|
if item['kodi_type'] == v.KODI_TYPE_MOVIE:
|
|
delete_movies.append(item)
|
|
elif item['kodi_type'] in v.KODI_VIDEOTYPES:
|
|
delete_tv.append(item)
|
|
elif item['kodi_type'] in v.KODI_AUDIOTYPES:
|
|
delete_music.append(item)
|
|
|
|
dialog('notification',
|
|
heading='{plex}',
|
|
message=lang(30052),
|
|
icon='{plex}',
|
|
sound=False)
|
|
for item in delete_movies:
|
|
with itemtypes.Movies() as movie_db:
|
|
movie_db.remove(item['plex_id'])
|
|
for item in delete_tv:
|
|
with itemtypes.TVShows() as tv_db:
|
|
tv_db.remove(item['plex_id'])
|
|
# And for the music DB:
|
|
for item in delete_music:
|
|
with itemtypes.Music() as music_db:
|
|
music_db.remove(item['plex_id'])
|
|
|
|
def get_updatelist(self, xml, item_class, method, view_name, view_id,
|
|
get_children=False):
|
|
"""
|
|
THIS METHOD NEEDS TO BE FAST! => e.g. no API calls
|
|
|
|
Adds items to self.updatelist as well as self.all_plex_ids dict
|
|
|
|
Input:
|
|
xml: PMS answer for section items
|
|
item_class: 'Movies', 'TVShows', ... see itemtypes.py
|
|
method: Method name to be called with this itemtype
|
|
see itemtypes.py
|
|
view_name: Name of the Plex view (e.g. 'My TV shows')
|
|
view_id: Id/Key of Plex library (e.g. '1')
|
|
get_children: will get Plex children of the item if True,
|
|
e.g. for music albums
|
|
|
|
Output: self.updatelist, self.all_plex_ids
|
|
self.updatelist APPENDED(!!) list itemids (Plex Keys as
|
|
as received from API.plex_id())
|
|
One item in this list is of the form:
|
|
'itemId': xxx,
|
|
'item_class': 'Movies','TVShows', ...
|
|
'method': 'add_update', 'add_updateSeason', ...
|
|
'view_name': xxx,
|
|
'view_id': xxx,
|
|
'title': xxx
|
|
'plex_type': xxx, e.g. 'movie', 'episode'
|
|
|
|
self.all_plex_ids APPENDED(!!) dict
|
|
= {itemid: checksum}
|
|
"""
|
|
if self.new_items_only is True:
|
|
# Only process Plex items that Kodi does not already have in lib
|
|
for item in xml:
|
|
plex_id = item.get('ratingKey')
|
|
if not plex_id:
|
|
# Skipping items 'title=All episodes' without a 'ratingKey'
|
|
continue
|
|
self.all_plex_ids[plex_id] = "K%s%s" % \
|
|
(plex_id, item.get('updatedAt', ''))
|
|
if plex_id not in self.all_kodi_ids:
|
|
self.updatelist.append({
|
|
'plex_id': plex_id,
|
|
'item_class': item_class,
|
|
'method': method,
|
|
'view_name': view_name,
|
|
'view_id': view_id,
|
|
'title': item.get('title', 'Missing Title'),
|
|
'plex_type': item.get('type'),
|
|
'get_children': get_children
|
|
})
|
|
elif self.compare:
|
|
# Only process the delta - new or changed items
|
|
for item in xml:
|
|
plex_id = item.get('ratingKey')
|
|
if not plex_id:
|
|
# Skipping items 'title=All episodes' without a 'ratingKey'
|
|
continue
|
|
plex_checksum = ("K%s%s"
|
|
% (plex_id, item.get('updatedAt', '')))
|
|
self.all_plex_ids[plex_id] = plex_checksum
|
|
kodi_checksum = self.all_kodi_ids.get(plex_id)
|
|
# Only update if movie is not in Kodi or checksum is
|
|
# different
|
|
if kodi_checksum != plex_checksum:
|
|
self.updatelist.append({
|
|
'plex_id': plex_id,
|
|
'item_class': item_class,
|
|
'method': method,
|
|
'view_name': view_name,
|
|
'view_id': view_id,
|
|
'title': item.get('title', 'Missing Title'),
|
|
'plex_type': item.get('type'),
|
|
'get_children': get_children
|
|
})
|
|
else:
|
|
# Initial or repair sync: get all Plex movies
|
|
for item in xml:
|
|
plex_id = item.get('ratingKey')
|
|
if not plex_id:
|
|
# Skipping items 'title=All episodes' without a 'ratingKey'
|
|
continue
|
|
self.all_plex_ids[plex_id] = "K%s%s" \
|
|
% (plex_id, item.get('updatedAt', ''))
|
|
self.updatelist.append({
|
|
'plex_id': plex_id,
|
|
'item_class': item_class,
|
|
'method': method,
|
|
'view_name': view_name,
|
|
'view_id': view_id,
|
|
'title': item.get('title', 'Missing Title'),
|
|
'plex_type': item.get('type'),
|
|
'get_children': get_children
|
|
})
|
|
|
|
def process_updatelist(self, item_class):
|
|
"""
|
|
Downloads all XMLs for item_class (e.g. Movies, TV-Shows). Processes them
|
|
by then calling item_classs.<item_class>()
|
|
|
|
Input:
|
|
item_class: 'Movies', 'TVShows', ...
|
|
self.updatelist
|
|
"""
|
|
# Some logging, just in case.
|
|
LOG.debug("self.updatelist: %s", self.updatelist)
|
|
item_number = len(self.updatelist)
|
|
if item_number == 0:
|
|
return
|
|
|
|
# Run through self.updatelist, get XML metadata per item
|
|
# Initiate threads
|
|
LOG.debug("Starting sync threads")
|
|
download_queue = Queue.Queue()
|
|
process_queue = Queue.Queue(maxsize=100)
|
|
# To keep track
|
|
sync_info.GET_METADATA_COUNT = 0
|
|
sync_info.PROCESS_METADATA_COUNT = 0
|
|
sync_info.PROCESSING_VIEW_NAME = ''
|
|
# Populate queue: GetMetadata
|
|
for item in self.updatelist:
|
|
download_queue.put(item)
|
|
# Spawn GetMetadata threads for downloading
|
|
threads = []
|
|
for _ in range(min(state.SYNC_THREAD_NUMBER, item_number)):
|
|
thread = ThreadedGetMetadata(download_queue, process_queue)
|
|
thread.setDaemon(True)
|
|
thread.start()
|
|
threads.append(thread)
|
|
LOG.debug("%s download threads spawned", len(threads))
|
|
# Spawn one more thread to process Metadata, once downloaded
|
|
thread = ThreadedProcessMetadata(process_queue, item_class)
|
|
thread.setDaemon(True)
|
|
thread.start()
|
|
threads.append(thread)
|
|
# Start one thread to show sync progress ONLY for new PMS items
|
|
if self.new_items_only is True and (state.SYNC_DIALOG is True or
|
|
self.force_dialog is True):
|
|
thread = sync_info.ThreadedShowSyncInfo(item_number, item_class)
|
|
thread.setDaemon(True)
|
|
thread.start()
|
|
threads.append(thread)
|
|
|
|
# Wait until finished
|
|
download_queue.join()
|
|
process_queue.join()
|
|
# Kill threads
|
|
LOG.debug("Waiting to kill threads")
|
|
for thread in threads:
|
|
# Threads might already have quit by themselves (e.g. Kodi exit)
|
|
try:
|
|
thread.stop()
|
|
except AttributeError:
|
|
pass
|
|
LOG.debug("Stop sent to all threads")
|
|
# Wait till threads are indeed dead
|
|
for thread in threads:
|
|
try:
|
|
thread.join(1.0)
|
|
except:
|
|
pass
|
|
LOG.debug("Sync threads finished")
|
|
if (settings('FanartTV') == 'true' and
|
|
item_class in ('Movies', 'TVShows')):
|
|
for item in self.updatelist:
|
|
if item['plex_type'] in (v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW):
|
|
self.fanartqueue.put({
|
|
'plex_id': item['plex_id'],
|
|
'plex_type': item['plex_type'],
|
|
'refresh': False
|
|
})
|
|
self.updatelist = []
|
|
|
|
@utils.log_time
|
|
def plex_movies(self):
|
|
# Initialize
|
|
self.all_plex_ids = {}
|
|
|
|
item_class = 'Movies'
|
|
|
|
views = [x for x in self.views if x['itemtype'] == v.KODI_TYPE_MOVIE]
|
|
LOG.info("Processing Plex %s. Libraries: %s", item_class, views)
|
|
|
|
self.all_kodi_ids = {}
|
|
if self.compare:
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
# Get movies from Plex server
|
|
# Pull the list of movies and boxsets in Kodi
|
|
try:
|
|
self.all_kodi_ids = dict(
|
|
plex_db.checksum(v.PLEX_TYPE_MOVIE))
|
|
except ValueError:
|
|
self.all_kodi_ids = {}
|
|
|
|
# PROCESS MOVIES #####
|
|
self.updatelist = []
|
|
for view in views:
|
|
if not self.install_sync_done:
|
|
state.PATH_VERIFIED = False
|
|
if self.suspend_item_sync():
|
|
return False
|
|
# Get items per view
|
|
all_plexmovies = PF.GetPlexSectionResults(view['id'], args=None)
|
|
if all_plexmovies is None:
|
|
LOG.info("Couldnt get section items, aborting for view.")
|
|
continue
|
|
elif all_plexmovies == 401:
|
|
return False
|
|
# Populate self.updatelist and self.all_plex_ids
|
|
self.get_updatelist(all_plexmovies,
|
|
item_class,
|
|
'add_update',
|
|
view['name'],
|
|
view['id'])
|
|
self.process_updatelist(item_class)
|
|
# Update viewstate for EVERY item
|
|
for view in views:
|
|
if self.suspend_item_sync():
|
|
return False
|
|
self.plex_update_watched(view['id'], item_class)
|
|
|
|
# PROCESS DELETES #####
|
|
if self.compare:
|
|
# Manual sync, process deletes
|
|
with itemtypes.Movies() as movie_db:
|
|
for kodimovie in self.all_kodi_ids:
|
|
if kodimovie not in self.all_plex_ids:
|
|
movie_db.remove(kodimovie)
|
|
LOG.info("%s sync is finished.", item_class)
|
|
return True
|
|
|
|
def plex_update_watched(self, viewId, item_class, lastViewedAt=None,
|
|
updatedAt=None):
|
|
"""
|
|
Updates plex elements' view status ('watched' or 'unwatched') and
|
|
also updates resume times.
|
|
This is done by downloading one XML for ALL elements with viewId
|
|
"""
|
|
if self.new_items_only is False:
|
|
# Only do this once for fullsync: the first run where new items are
|
|
# added to Kodi
|
|
return
|
|
xml = PF.GetAllPlexLeaves(viewId,
|
|
lastViewedAt=lastViewedAt,
|
|
updatedAt=updatedAt)
|
|
# Return if there are no items in PMS reply - it's faster
|
|
try:
|
|
xml[0].attrib
|
|
except (TypeError, AttributeError, IndexError):
|
|
LOG.error('Error updating watch status. Could not get viewId: '
|
|
'%s of item_class %s with lastViewedAt: %s, updatedAt: '
|
|
'%s', viewId, item_class, lastViewedAt, updatedAt)
|
|
return
|
|
|
|
if item_class in ('Movies', 'TVShows'):
|
|
self.update_kodi_video_library = True
|
|
elif item_class == 'Music':
|
|
self.update_kodi_music_library = True
|
|
with getattr(itemtypes, item_class)() as itemtype:
|
|
itemtype.updateUserdata(xml)
|
|
|
|
@utils.log_time
|
|
def plex_tv_show(self):
|
|
# Initialize
|
|
self.all_plex_ids = {}
|
|
item_class = 'TVShows'
|
|
|
|
views = [x for x in self.views if x['itemtype'] == 'show']
|
|
LOG.info("Media folders for %s: %s", item_class, views)
|
|
|
|
self.all_kodi_ids = {}
|
|
if self.compare:
|
|
with plexdb.Get_Plex_DB() as plex:
|
|
# Pull the list of TV shows already in Kodi
|
|
for kind in (v.PLEX_TYPE_SHOW,
|
|
v.PLEX_TYPE_SEASON,
|
|
v.PLEX_TYPE_EPISODE):
|
|
try:
|
|
elements = dict(plex.checksum(kind))
|
|
self.all_kodi_ids.update(elements)
|
|
# Yet empty/not yet synched
|
|
except ValueError:
|
|
pass
|
|
|
|
# PROCESS TV Shows #####
|
|
self.updatelist = []
|
|
for view in views:
|
|
if not self.install_sync_done:
|
|
state.PATH_VERIFIED = False
|
|
if self.suspend_item_sync():
|
|
return False
|
|
# Get items per view
|
|
view_id = view['id']
|
|
view_name = view['name']
|
|
all_plex_tv_shows = PF.GetPlexSectionResults(view_id)
|
|
if all_plex_tv_shows is None:
|
|
LOG.error("Error downloading show xml for view %s", view_id)
|
|
continue
|
|
elif all_plex_tv_shows == 401:
|
|
return False
|
|
# Populate self.updatelist and self.all_plex_ids
|
|
self.get_updatelist(all_plex_tv_shows,
|
|
item_class,
|
|
'add_update',
|
|
view_name,
|
|
view_id)
|
|
LOG.debug("Analyzed view %s with ID %s", view_name, view_id)
|
|
|
|
# COPY for later use
|
|
all_plex_tv_show_ids = self.all_plex_ids.copy()
|
|
|
|
# Process self.updatelist
|
|
self.process_updatelist(item_class)
|
|
LOG.debug("process_updatelist completed for tv shows")
|
|
|
|
# PROCESS TV Seasons #####
|
|
# Cycle through tv shows
|
|
for show_id in all_plex_tv_show_ids:
|
|
if self.suspend_item_sync():
|
|
return False
|
|
# Grab all seasons to tvshow from PMS
|
|
seasons = PF.GetAllPlexChildren(show_id)
|
|
if seasons is None:
|
|
LOG.error("Error download season xml for show %s", show_id)
|
|
continue
|
|
elif seasons == 401:
|
|
return False
|
|
# Populate self.updatelist and self.all_plex_ids
|
|
self.get_updatelist(seasons,
|
|
item_class,
|
|
'add_updateSeason',
|
|
view_name,
|
|
view_id)
|
|
LOG.debug("Analyzed all seasons of TV show with Plex Id %s",
|
|
show_id)
|
|
|
|
# Process self.updatelist
|
|
self.process_updatelist(item_class)
|
|
LOG.debug("process_updatelist completed for seasons")
|
|
|
|
# PROCESS TV Episodes #####
|
|
# Cycle through tv shows
|
|
for view in views:
|
|
if self.suspend_item_sync():
|
|
return False
|
|
# Grab all episodes to tvshow from PMS
|
|
episodes = PF.GetAllPlexLeaves(view['id'])
|
|
if episodes is None:
|
|
LOG.error("Error downloading episod xml for view %s",
|
|
view.get('name'))
|
|
continue
|
|
elif episodes == 401:
|
|
return False
|
|
# Populate self.updatelist and self.all_plex_ids
|
|
self.get_updatelist(episodes,
|
|
item_class,
|
|
'add_updateEpisode',
|
|
view_name,
|
|
view_id)
|
|
LOG.debug("Analyzed all episodes of TV show with Plex Id %s",
|
|
view['id'])
|
|
|
|
# Process self.updatelist
|
|
self.process_updatelist(item_class)
|
|
LOG.debug("process_updatelist completed for episodes")
|
|
# Refresh season info
|
|
# Cycle through tv shows
|
|
with itemtypes.TVShows() as tvshow_db:
|
|
for show_id in all_plex_tv_show_ids:
|
|
xml_show = PF.GetPlexMetadata(show_id)
|
|
if xml_show is None or xml_show == 401:
|
|
LOG.error('Could not download xml_show')
|
|
continue
|
|
tvshow_db.refreshSeasonEntry(xml_show, show_id)
|
|
LOG.debug("Season info refreshed")
|
|
|
|
# Update viewstate:
|
|
for view in views:
|
|
if self.suspend_item_sync():
|
|
return False
|
|
self.plex_update_watched(view['id'], item_class)
|
|
|
|
if self.compare:
|
|
# Manual sync, process deletes
|
|
with itemtypes.TVShows() as tvshow_db:
|
|
for item in self.all_kodi_ids:
|
|
if item not in self.all_plex_ids:
|
|
tvshow_db.remove(item)
|
|
LOG.info("%s sync is finished.", item_class)
|
|
return True
|
|
|
|
@utils.log_time
|
|
def plex_music(self):
|
|
item_class = 'Music'
|
|
|
|
views = [x for x in self.views if x['itemtype'] == v.PLEX_TYPE_ARTIST]
|
|
LOG.info("Media folders for %s: %s", item_class, views)
|
|
|
|
methods = {
|
|
v.PLEX_TYPE_ARTIST: 'add_updateArtist',
|
|
v.PLEX_TYPE_ALBUM: 'add_updateAlbum',
|
|
v.PLEX_TYPE_SONG: 'add_updateSong'
|
|
}
|
|
urlArgs = {
|
|
v.PLEX_TYPE_ARTIST: {'type': 8},
|
|
v.PLEX_TYPE_ALBUM: {'type': 9},
|
|
v.PLEX_TYPE_SONG: {'type': 10}
|
|
}
|
|
|
|
# Process artist, then album and tracks last to minimize overhead
|
|
# Each album needs to be processed directly with its songs
|
|
# Remaining songs without album will be processed last
|
|
for kind in (v.PLEX_TYPE_ARTIST,
|
|
v.PLEX_TYPE_ALBUM,
|
|
v.PLEX_TYPE_SONG):
|
|
if self.suspend_item_sync():
|
|
return False
|
|
LOG.debug("Start processing music %s", kind)
|
|
self.all_kodi_ids = {}
|
|
self.all_plex_ids = {}
|
|
self.updatelist = []
|
|
if not self.process_music(views,
|
|
kind,
|
|
urlArgs[kind],
|
|
methods[kind]):
|
|
return False
|
|
LOG.debug("Processing of music %s done", kind)
|
|
self.process_updatelist(item_class)
|
|
LOG.debug("process_updatelist for music %s completed", kind)
|
|
|
|
# Update viewstate for EVERY item
|
|
for view in views:
|
|
if self.suspend_item_sync():
|
|
return False
|
|
self.plex_update_watched(view['id'], item_class)
|
|
|
|
# reset stuff
|
|
self.all_kodi_ids = {}
|
|
self.all_plex_ids = {}
|
|
self.updatelist = []
|
|
LOG.info("%s sync is finished.", item_class)
|
|
return True
|
|
|
|
def process_music(self, views, kind, urlArgs, method):
|
|
# For albums, we need to look at the album's songs simultaneously
|
|
get_children = True if kind == v.PLEX_TYPE_ALBUM else False
|
|
# Get a list of items already existing in Kodi db
|
|
if self.compare:
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
# Pull the list of items already in Kodi
|
|
try:
|
|
elements = dict(plex_db.checksum(kind))
|
|
self.all_kodi_ids.update(elements)
|
|
# Yet empty/nothing yet synched
|
|
except ValueError:
|
|
pass
|
|
for view in views:
|
|
if not self.install_sync_done:
|
|
state.PATH_VERIFIED = False
|
|
if self.suspend_item_sync():
|
|
return False
|
|
# Get items per view
|
|
items_xml = PF.GetPlexSectionResults(view['id'], args=urlArgs)
|
|
if items_xml is None:
|
|
LOG.error("Error downloading xml for view %s", view['id'])
|
|
continue
|
|
elif items_xml == 401:
|
|
return False
|
|
# Populate self.updatelist and self.all_plex_ids
|
|
self.get_updatelist(items_xml,
|
|
'Music',
|
|
method,
|
|
view['name'],
|
|
view['id'],
|
|
get_children=get_children)
|
|
if self.compare:
|
|
# Manual sync, process deletes
|
|
with itemtypes.Music() as music_db:
|
|
for itemid in self.all_kodi_ids:
|
|
if itemid not in self.all_plex_ids:
|
|
music_db.remove(itemid)
|
|
return True
|
|
|
|
def process_message(self, message):
|
|
"""
|
|
processes json.loads() messages from websocket. Triage what we need to
|
|
do with "process_" methods
|
|
"""
|
|
if message['type'] == 'playing':
|
|
try:
|
|
self.process_playing(message['PlaySessionStateNotification'])
|
|
except KeyError:
|
|
LOG.error('Received invalid PMS message for playstate: %s',
|
|
message)
|
|
elif message['type'] == 'timeline':
|
|
try:
|
|
self.process_timeline(message['TimelineEntry'])
|
|
except (KeyError, ValueError):
|
|
LOG.error('Received invalid PMS message for timeline: %s',
|
|
message)
|
|
elif message['type'] == 'activity':
|
|
try:
|
|
self.process_activity(message['ActivityNotification'])
|
|
except KeyError:
|
|
LOG.error('Received invalid PMS message for activity: %s',
|
|
message)
|
|
|
|
def multi_delete(self, liste, delete_list):
|
|
"""
|
|
Deletes the list items of liste at the positions in delete_list
|
|
(which can be in any arbitrary order)
|
|
"""
|
|
indexes = sorted(delete_list, reverse=True)
|
|
for index in indexes:
|
|
del liste[index]
|
|
return liste
|
|
|
|
def process_items(self):
|
|
"""
|
|
Periodically called to process new/updated PMS items
|
|
|
|
PMS needs a while to download info from internet AFTER it
|
|
showed up under 'timeline' websocket messages
|
|
|
|
data['type']:
|
|
1: movie
|
|
2: tv show??
|
|
3: season??
|
|
4: episode
|
|
8: artist (band)
|
|
9: album
|
|
10: track (song)
|
|
12: trailer, extras?
|
|
|
|
data['state']:
|
|
0: 'created',
|
|
2: 'matching',
|
|
3: 'downloading',
|
|
4: 'loading',
|
|
5: 'finished',
|
|
6: 'analyzing',
|
|
9: 'deleted'
|
|
"""
|
|
self.update_kodi_video_library = False
|
|
self.update_kodi_music_library = False
|
|
now = utils.unix_timestamp()
|
|
delete_list = []
|
|
for i, item in enumerate(self.items_to_process):
|
|
if self.stopped() or self.suspended():
|
|
# Chances are that Kodi gets shut down
|
|
break
|
|
if item['state'] == 9:
|
|
successful = self.process_deleteditems(item)
|
|
elif now - item['timestamp'] < state.BACKGROUNDSYNC_SAFTYMARGIN:
|
|
# We haven't waited long enough for the PMS to finish
|
|
# processing the item. Do it later (excepting deletions)
|
|
continue
|
|
else:
|
|
successful = self.process_newitems(item)
|
|
if successful and settings('FanartTV') == 'true':
|
|
if item['type'] in (v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW):
|
|
self.fanartqueue.put({
|
|
'plex_id': item['ratingKey'],
|
|
'plex_type': item['type'],
|
|
'refresh': False
|
|
})
|
|
if successful is True:
|
|
delete_list.append(i)
|
|
else:
|
|
# Safety net if we can't process an item
|
|
item['attempt'] += 1
|
|
if item['attempt'] > 3:
|
|
LOG.error('Repeatedly could not process item %s, abort',
|
|
item)
|
|
delete_list.append(i)
|
|
|
|
# Get rid of the items we just processed
|
|
if delete_list:
|
|
self.items_to_process = self.multi_delete(self.items_to_process,
|
|
delete_list)
|
|
# Let Kodi know of the change
|
|
if self.update_kodi_video_library is True:
|
|
LOG.info("Doing Kodi Video Lib update")
|
|
xbmc.executebuiltin('UpdateLibrary(video)')
|
|
if self.update_kodi_music_library is True:
|
|
LOG.info("Doing Kodi Music Lib update")
|
|
xbmc.executebuiltin('UpdateLibrary(music)')
|
|
|
|
def process_newitems(self, item):
|
|
xml = PF.GetPlexMetadata(item['ratingKey'])
|
|
try:
|
|
mediatype = xml[0].attrib['type']
|
|
except (IndexError, KeyError, TypeError):
|
|
LOG.error('Could not download metadata for %s', item['ratingKey'])
|
|
return False
|
|
LOG.debug("Processing new/updated PMS item: %s", item['ratingKey'])
|
|
viewtag = xml.attrib.get('librarySectionTitle')
|
|
viewid = xml.attrib.get('librarySectionID')
|
|
if mediatype == v.PLEX_TYPE_MOVIE:
|
|
self.update_kodi_video_library = True
|
|
with itemtypes.Movies() as movie:
|
|
movie.add_update(xml[0],
|
|
viewtag=viewtag,
|
|
viewid=viewid)
|
|
elif mediatype == v.PLEX_TYPE_EPISODE:
|
|
self.update_kodi_video_library = True
|
|
with itemtypes.TVShows() as show:
|
|
show.add_updateEpisode(xml[0],
|
|
viewtag=viewtag,
|
|
viewid=viewid)
|
|
elif mediatype == v.PLEX_TYPE_SONG:
|
|
self.update_kodi_music_library = True
|
|
with itemtypes.Music() as music_db:
|
|
music_db.add_updateSong(xml[0], viewtag=viewtag, viewid=viewid)
|
|
return True
|
|
|
|
def process_deleteditems(self, item):
|
|
if item['type'] == v.PLEX_TYPE_MOVIE:
|
|
LOG.debug("Removing movie %s", item['ratingKey'])
|
|
self.update_kodi_video_library = True
|
|
with itemtypes.Movies() as movie:
|
|
movie.remove(item['ratingKey'])
|
|
elif item['type'] in (v.PLEX_TYPE_SHOW,
|
|
v.PLEX_TYPE_SEASON,
|
|
v.PLEX_TYPE_EPISODE):
|
|
LOG.debug("Removing episode/season/show with plex id %s",
|
|
item['ratingKey'])
|
|
self.update_kodi_video_library = True
|
|
with itemtypes.TVShows() as show:
|
|
show.remove(item['ratingKey'])
|
|
elif item['type'] in (v.PLEX_TYPE_ARTIST,
|
|
v.PLEX_TYPE_ALBUM,
|
|
v.PLEX_TYPE_SONG):
|
|
LOG.debug("Removing song/album/artist %s", item['ratingKey'])
|
|
self.update_kodi_music_library = True
|
|
with itemtypes.Music() as music_db:
|
|
music_db.remove(item['ratingKey'])
|
|
return True
|
|
|
|
def process_timeline(self, data):
|
|
"""
|
|
PMS is messing with the library items, e.g. new or changed. Put in our
|
|
"processing queue" for later
|
|
"""
|
|
for item in data:
|
|
if 'tv.plex' in item.get('identifier', ''):
|
|
# Ommit Plex DVR messages - the Plex IDs are not corresponding
|
|
# (DVR ratingKeys are not unique and might correspond to a
|
|
# movie or episode)
|
|
continue
|
|
typus = v.PLEX_TYPE_FROM_WEBSOCKET[int(item['type'])]
|
|
if typus == v.PLEX_TYPE_CLIP:
|
|
# No need to process extras or trailers
|
|
continue
|
|
status = int(item['state'])
|
|
if typus == 'playlist':
|
|
if not state.SYNC_PLAYLISTS:
|
|
continue
|
|
playlists.process_websocket(plex_id=str(item['itemID']),
|
|
updated_at=str(item['updatedAt']),
|
|
state=status)
|
|
elif status == 9:
|
|
# Immediately and always process deletions (as the PMS will
|
|
# send additional message with other codes)
|
|
self.items_to_process.append({
|
|
'state': status,
|
|
'type': typus,
|
|
'ratingKey': str(item['itemID']),
|
|
'timestamp': utils.unix_timestamp(),
|
|
'attempt': 0
|
|
})
|
|
elif typus in (v.PLEX_TYPE_MOVIE,
|
|
v.PLEX_TYPE_EPISODE,
|
|
v.PLEX_TYPE_SONG) and status == 5:
|
|
plex_id = str(item['itemID'])
|
|
# Have we already added this element for processing?
|
|
for existing_item in self.items_to_process:
|
|
if existing_item['ratingKey'] == plex_id:
|
|
break
|
|
else:
|
|
# Haven't added this element to the queue yet
|
|
self.items_to_process.append({
|
|
'state': status,
|
|
'type': typus,
|
|
'ratingKey': plex_id,
|
|
'timestamp': utils.unix_timestamp(),
|
|
'attempt': 0
|
|
})
|
|
|
|
def process_activity(self, data):
|
|
"""
|
|
PMS is re-scanning an item, e.g. after having changed a movie poster.
|
|
WATCH OUT for this if it's triggered by our PKC library scan!
|
|
"""
|
|
for item in data:
|
|
if item['event'] != 'ended':
|
|
# Scan still going on, so skip for now
|
|
continue
|
|
elif item['Activity'].get('Context') is None:
|
|
# Not related to any Plex element, but entire library
|
|
continue
|
|
elif item['Activity']['type'] != 'library.refresh.items':
|
|
# Not the type of message relevant for us
|
|
continue
|
|
plex_id = PF.GetPlexKeyNumber(item['Activity']['Context']['key'])[1]
|
|
if plex_id == '':
|
|
# Likely a Plex id like /library/metadata/3/children
|
|
continue
|
|
# We're only looking at existing elements - have we synced yet?
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
kodi_info = plex_db.getItem_byId(plex_id)
|
|
if kodi_info is None:
|
|
LOG.debug('Plex id %s not synced yet - skipping', plex_id)
|
|
continue
|
|
# Have we already added this element?
|
|
for existing_item in self.items_to_process:
|
|
if existing_item['ratingKey'] == plex_id:
|
|
break
|
|
else:
|
|
# Haven't added this element to the queue yet
|
|
self.items_to_process.append({
|
|
'state': None, # Don't need a state here
|
|
'type': kodi_info[5],
|
|
'ratingKey': plex_id,
|
|
'timestamp': utils.unix_timestamp(),
|
|
'attempt': 0
|
|
})
|
|
|
|
def process_playing(self, data):
|
|
"""
|
|
Someone (not necessarily the user signed in) is playing something some-
|
|
where
|
|
"""
|
|
for item in data:
|
|
status = item['state']
|
|
if status == 'buffering':
|
|
# Drop buffering messages immediately
|
|
continue
|
|
plex_id = item['ratingKey']
|
|
skip = False
|
|
for pid in (0, 1, 2):
|
|
if plex_id == state.PLAYER_STATES[pid]['plex_id']:
|
|
# Kodi is playing this item - no need to set the playstate
|
|
skip = True
|
|
if skip:
|
|
continue
|
|
session_key = item['sessionKey']
|
|
# Do we already have a sessionKey stored?
|
|
if session_key not in self.session_keys:
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
kodi_info = plex_db.getItem_byId(plex_id)
|
|
if kodi_info is None:
|
|
# Item not (yet) in Kodi library
|
|
continue
|
|
if settings('plex_serverowned') == 'false':
|
|
# Not our PMS, we are not authorized to get the sessions
|
|
# On the bright side, it must be us playing :-)
|
|
self.session_keys[session_key] = {}
|
|
else:
|
|
# PMS is ours - get all current sessions
|
|
self.session_keys.update(PF.GetPMSStatus(state.PLEX_TOKEN))
|
|
LOG.debug('Updated current sessions. They are: %s',
|
|
self.session_keys)
|
|
if session_key not in self.session_keys:
|
|
LOG.info('Session key %s still unknown! Skip '
|
|
'playstate update', session_key)
|
|
continue
|
|
# Attach Kodi info to the session
|
|
self.session_keys[session_key]['kodi_id'] = kodi_info[0]
|
|
self.session_keys[session_key]['file_id'] = kodi_info[1]
|
|
self.session_keys[session_key]['kodi_type'] = kodi_info[4]
|
|
session = self.session_keys[session_key]
|
|
if settings('plex_serverowned') != 'false':
|
|
# Identify the user - same one as signed on with PKC? Skip
|
|
# update if neither session's username nor userid match
|
|
# (Owner sometime's returns id '1', not always)
|
|
if not state.PLEX_TOKEN and session['userId'] == '1':
|
|
# PKC not signed in to plex.tv. Plus owner of PMS is
|
|
# playing (the '1').
|
|
# Hence must be us (since several users require plex.tv
|
|
# token for PKC)
|
|
pass
|
|
elif not (session['userId'] == state.PLEX_USER_ID or
|
|
session['username'] == state.PLEX_USERNAME):
|
|
LOG.debug('Our username %s, userid %s did not match '
|
|
'the session username %s with userid %s',
|
|
state.PLEX_USERNAME,
|
|
state.PLEX_USER_ID,
|
|
session['username'],
|
|
session['userId'])
|
|
continue
|
|
# Get an up-to-date XML from the PMS because PMS will NOT directly
|
|
# tell us: duration of item viewCount
|
|
if session.get('duration') is None:
|
|
xml = PF.GetPlexMetadata(plex_id)
|
|
if xml in (None, 401):
|
|
LOG.error('Could not get up-to-date xml for item %s',
|
|
plex_id)
|
|
continue
|
|
api = PlexAPI.API(xml[0])
|
|
userdata = api.userdata()
|
|
session['duration'] = userdata['Runtime']
|
|
session['viewCount'] = userdata['PlayCount']
|
|
# Sometimes, Plex tells us resume points in milliseconds and
|
|
# not in seconds - thank you very much!
|
|
if item['viewOffset'] > session['duration']:
|
|
resume = item['viewOffset'] / 1000
|
|
else:
|
|
resume = item['viewOffset']
|
|
if resume < v.IGNORE_SECONDS_AT_START:
|
|
continue
|
|
try:
|
|
completed = float(resume) / float(session['duration'])
|
|
except (ZeroDivisionError, TypeError):
|
|
LOG.error('Could not mark playstate for %s and session %s',
|
|
data, session)
|
|
continue
|
|
if completed >= v.MARK_PLAYED_AT:
|
|
# Only mark completely watched ONCE
|
|
if session.get('marked_played') is None:
|
|
session['marked_played'] = True
|
|
mark_played = True
|
|
else:
|
|
# Don't mark it as completely watched again
|
|
continue
|
|
else:
|
|
mark_played = False
|
|
LOG.debug('Update playstate for user %s with id %s for plex id %s',
|
|
state.PLEX_USERNAME, state.PLEX_USER_ID, plex_id)
|
|
item_fkt = getattr(itemtypes,
|
|
v.ITEMTYPE_FROM_KODITYPE[session['kodi_type']])
|
|
with item_fkt() as fkt:
|
|
fkt.updatePlaystate(mark_played,
|
|
session['viewCount'],
|
|
resume,
|
|
session['duration'],
|
|
session['file_id'],
|
|
utils.unix_date_to_kodi(utils.unix_timestamp()))
|
|
|
|
def sync_fanart(self, missing_only=True, refresh=False):
|
|
"""
|
|
Throw items to the fanart queue in order to download missing (or all)
|
|
additional fanart.
|
|
|
|
missing_only=True False will start look-up for EVERY item
|
|
refresh=False True will force refresh all external fanart
|
|
"""
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
if missing_only:
|
|
with plexdb.Get_Plex_DB() as plex_db:
|
|
items = plex_db.get_missing_fanart()
|
|
LOG.info('Trying to get %s additional fanart', len(items))
|
|
else:
|
|
items = []
|
|
for plex_type in (v.PLEX_TYPE_MOVIE, v.PLEX_TYPE_SHOW):
|
|
items.extend(plex_db.itemsByType(plex_type))
|
|
LOG.info('Trying to get ALL additional fanart for %s items',
|
|
len(items))
|
|
# Shuffle the list to not always start out identically
|
|
shuffle(items)
|
|
for item in items:
|
|
self.fanartqueue.put({
|
|
'plex_id': item['plex_id'],
|
|
'plex_type': item['plex_type'],
|
|
'refresh': refresh
|
|
})
|
|
|
|
def triage_lib_scans(self):
|
|
"""
|
|
Decides what to do if state.RUN_LIB_SCAN has been set. E.g. manually
|
|
triggered full or repair syncs
|
|
"""
|
|
if state.RUN_LIB_SCAN in ("full", "repair"):
|
|
LOG.info('Full library scan requested, starting')
|
|
window('plex_dbScan', value="true")
|
|
state.DB_SCAN = True
|
|
success = self.maintain_views()
|
|
if success and state.RUN_LIB_SCAN == "full":
|
|
success = self.full_sync()
|
|
elif success:
|
|
success = self.full_sync(repair=True)
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
if success:
|
|
# Full library sync finished
|
|
self.show_kodi_note(lang(39407))
|
|
elif not self.suspend_item_sync():
|
|
self.force_dialog = True
|
|
# ERROR in library sync
|
|
self.show_kodi_note(lang(39410), icon='error')
|
|
self.force_dialog = False
|
|
# Reset views was requested from somewhere else
|
|
elif state.RUN_LIB_SCAN == "views":
|
|
LOG.info('Refresh playlist and nodes requested, starting')
|
|
window('plex_dbScan', value="true")
|
|
state.DB_SCAN = True
|
|
# First remove playlists
|
|
utils.delete_playlists()
|
|
# Remove video nodes
|
|
utils.delete_nodes()
|
|
# Kick off refresh
|
|
if self.maintain_views() is True:
|
|
# Ran successfully
|
|
LOG.info("Refresh playlists/nodes completed")
|
|
# "Plex playlists/nodes refreshed"
|
|
self.show_kodi_note(lang(39405))
|
|
else:
|
|
# Failed
|
|
LOG.error("Refresh playlists/nodes failed")
|
|
# "Plex playlists/nodes refresh failed"
|
|
self.show_kodi_note(lang(39406), icon="error")
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
elif state.RUN_LIB_SCAN == 'fanart':
|
|
# Only look for missing fanart (No)
|
|
# or refresh all fanart (Yes)
|
|
refresh = dialog('yesno',
|
|
heading='{plex}',
|
|
line1=lang(39223),
|
|
nolabel=lang(39224),
|
|
yeslabel=lang(39225))
|
|
self.sync_fanart(missing_only=not refresh, refresh=refresh)
|
|
elif state.RUN_LIB_SCAN == 'textures':
|
|
state.DB_SCAN = True
|
|
window('plex_dbScan', value="true")
|
|
artwork.Artwork().fullTextureCacheSync()
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
else:
|
|
raise NotImplementedError('Library scan not defined: %s'
|
|
% state.RUN_LIB_SCAN)
|
|
# Reset
|
|
state.RUN_LIB_SCAN = None
|
|
|
|
def run(self):
|
|
try:
|
|
self._run_internal()
|
|
except Exception as e:
|
|
state.DB_SCAN = False
|
|
window('plex_dbScan', clear=True)
|
|
LOG.error('LibrarySync thread crashed. Error message: %s', e)
|
|
import traceback
|
|
LOG.error("Traceback:\n%s", traceback.format_exc())
|
|
# Library sync thread has crashed
|
|
dialog('ok', heading='{plex}', line1=lang(39400))
|
|
raise
|
|
|
|
def _run_internal(self):
|
|
LOG.info("---===### Starting LibrarySync ###===---")
|
|
initial_sync_done = False
|
|
kodi_db_version_checked = False
|
|
last_sync = 0
|
|
last_processing = 0
|
|
one_day_in_seconds = 60*60*24
|
|
# Link to Websocket queue
|
|
queue = state.WEBSOCKET_QUEUE
|
|
|
|
if not exists(try_encode(v.DB_VIDEO_PATH)):
|
|
# Database does not exists
|
|
LOG.error("The current Kodi version is incompatible "
|
|
"to know which Kodi versions are supported.")
|
|
LOG.error('Current Kodi version: %s', try_decode(
|
|
xbmc.getInfoLabel('System.BuildVersion')))
|
|
# "Current Kodi version is unsupported, cancel lib sync"
|
|
dialog('ok', heading='{plex}', line1=lang(39403))
|
|
return
|
|
|
|
# Do some initializing
|
|
# Ensure that DBs exist if called for very first time
|
|
self.initialize_plex_db()
|
|
# Run start up sync
|
|
state.DB_SCAN = True
|
|
window('plex_dbScan', value="true")
|
|
LOG.info("Db version: %s", settings('dbCreatedWithVersion'))
|
|
|
|
LOG.info('Refreshing video nodes and playlists now')
|
|
# Completely refresh Kodi playlists and video nodes
|
|
utils.delete_playlists()
|
|
utils.delete_nodes()
|
|
self.maintain_views()
|
|
# Setup the paths for addon-paths (even when using direct paths)
|
|
with kodidb.GetKodiDB('video') as kodi_db:
|
|
kodi_db.setup_path_table()
|
|
# Initialize time offset Kodi - PMS
|
|
self.sync_pms_time()
|
|
last_time_sync = utils.unix_timestamp()
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
playlist_monitor = None
|
|
|
|
while not self.stopped():
|
|
# In the event the server goes offline
|
|
while self.suspended():
|
|
if self.stopped():
|
|
# Abort was requested while waiting. We should exit
|
|
LOG.info("###===--- LibrarySync Stopped ---===###")
|
|
return
|
|
xbmc.sleep(1000)
|
|
|
|
if not self.install_sync_done:
|
|
# Very first sync upon installation or reset of Kodi DB
|
|
state.DB_SCAN = True
|
|
window('plex_dbScan', value='true')
|
|
LOG.info('Initial start-up full sync starting')
|
|
xbmc.executebuiltin('InhibitIdleShutdown(true)')
|
|
if self.full_sync():
|
|
LOG.info('Initial start-up full sync successful')
|
|
settings('SyncInstallRunDone', value='true')
|
|
self.install_sync_done = True
|
|
settings('dbCreatedWithVersion', v.ADDON_VERSION)
|
|
self.force_dialog = False
|
|
initial_sync_done = True
|
|
kodi_db_version_checked = True
|
|
last_sync = utils.unix_timestamp()
|
|
self.fanartthread.start()
|
|
if state.SYNC_PLAYLISTS and playlists.full_sync():
|
|
playlist_monitor = playlists.kodi_playlist_monitor()
|
|
else:
|
|
LOG.error('Initial start-up full sync unsuccessful')
|
|
xbmc.executebuiltin('InhibitIdleShutdown(false)')
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
if settings('FanartTV') == 'true':
|
|
self.sync_fanart()
|
|
|
|
elif not kodi_db_version_checked:
|
|
# Install sync was already done, don't force-show dialogs
|
|
self.force_dialog = False
|
|
# Verify the validity of the database
|
|
current_version = settings('dbCreatedWithVersion')
|
|
if not utils.compare_version(current_version, v.MIN_DB_VERSION):
|
|
LOG.warn("Db version out of date: %s minimum version "
|
|
"required: %s", current_version, v.MIN_DB_VERSION)
|
|
# DB out of date. Proceed to recreate?
|
|
resp = dialog('yesno',
|
|
heading=lang(29999),
|
|
line1=lang(39401))
|
|
if not resp:
|
|
LOG.warn("Db version out of date! USER IGNORED!")
|
|
# PKC may not work correctly until reset
|
|
dialog('ok',
|
|
heading='{plex}',
|
|
line1=lang(29999) + lang(39402))
|
|
else:
|
|
utils.reset()
|
|
break
|
|
kodi_db_version_checked = True
|
|
|
|
elif not initial_sync_done:
|
|
# First sync upon PKC restart. Skipped if very first sync upon
|
|
# PKC installation has been completed
|
|
state.DB_SCAN = True
|
|
window('plex_dbScan', value="true")
|
|
LOG.info('Doing initial sync on Kodi startup')
|
|
if self.full_sync():
|
|
initial_sync_done = True
|
|
last_sync = utils.unix_timestamp()
|
|
if settings('FanartTV') == 'true':
|
|
self.sync_fanart()
|
|
LOG.info('Done initial sync on Kodi startup')
|
|
artwork.Artwork().cache_major_artwork()
|
|
self.fanartthread.start()
|
|
if state.SYNC_PLAYLISTS and playlists.full_sync():
|
|
playlist_monitor = playlists.kodi_playlist_monitor()
|
|
else:
|
|
LOG.info('Startup sync has not yet been successful')
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
|
|
# Currently no db scan, so we can start a new scan
|
|
elif state.DB_SCAN is False:
|
|
# Full scan was requested from somewhere else, e.g. userclient
|
|
if state.RUN_LIB_SCAN is not None:
|
|
# Force-show dialogs since they are user-initiated
|
|
self.force_dialog = True
|
|
self.triage_lib_scans()
|
|
self.force_dialog = False
|
|
continue
|
|
now = utils.unix_timestamp()
|
|
# Standard syncs - don't force-show dialogs
|
|
self.force_dialog = False
|
|
if (now - last_sync > state.FULL_SYNC_INTERVALL and
|
|
not self.suspend_item_sync()):
|
|
LOG.info('Doing scheduled full library scan')
|
|
state.DB_SCAN = True
|
|
window('plex_dbScan', value="true")
|
|
success = self.maintain_views()
|
|
if success:
|
|
success = self.full_sync()
|
|
if not success and not self.suspend_item_sync():
|
|
LOG.error('Could not finish scheduled full sync')
|
|
self.force_dialog = True
|
|
self.show_kodi_note(lang(39410),
|
|
icon='error')
|
|
self.force_dialog = False
|
|
elif success:
|
|
last_sync = now
|
|
# Full library sync finished successfully
|
|
self.show_kodi_note(lang(39407))
|
|
else:
|
|
LOG.info('Full sync interrupted')
|
|
window('plex_dbScan', clear=True)
|
|
state.DB_SCAN = False
|
|
elif now - last_time_sync > one_day_in_seconds:
|
|
LOG.info('Starting daily time sync')
|
|
self.sync_pms_time()
|
|
last_time_sync = now
|
|
elif not state.BACKGROUND_SYNC_DISABLED:
|
|
# Check back whether we should process something
|
|
# Only do this once every while (otherwise, potentially
|
|
# many screen refreshes lead to flickering)
|
|
if now - last_processing > 5:
|
|
last_processing = now
|
|
self.process_items()
|
|
# See if there is a PMS message we need to handle
|
|
try:
|
|
message = queue.get(block=False)
|
|
except Queue.Empty:
|
|
pass
|
|
# Got a message from PMS; process it
|
|
else:
|
|
self.process_message(message)
|
|
queue.task_done()
|
|
# Sleep just a bit
|
|
xbmc.sleep(10)
|
|
continue
|
|
xbmc.sleep(100)
|
|
# Shut down playlist monitoring
|
|
if playlist_monitor:
|
|
playlist_monitor.stop()
|
|
# doUtils could still have a session open due to interrupted sync
|
|
try:
|
|
DU().stopSession()
|
|
except:
|
|
pass
|
|
LOG.info("###===--- LibrarySync Stopped ---===###")
|