# -*- coding: utf-8 -*- from __future__ import division, absolute_import, print_function, unicode_literals ################################################################################################## import threading from datetime import datetime, timedelta import queue from kodi_six import xbmc, xbmcgui from .objects import Movies, TVShows, MusicVideos, Music from .objects.kodi import Movies as KodiDb from .database import Database, jellyfin_db, get_sync, save_sync from .full_sync import FullSync from .views import Views from .downloader import GetItemWorker from .helper import translate, api, stop, settings, window, dialog, event, LazyLogger from .helper.utils import split_list, set_screensaver, get_screensaver from .helper.exceptions import LibraryException from .jellyfin import Jellyfin ################################################################################################## LOG = LazyLogger(__name__) LIMIT = int(settings("limitIndex") or 15) DTHREADS = int(settings("limitThreads") or 3) TARGET_DB_VERSION = 1 ################################################################################################## class Library(threading.Thread): started = False stop_thread = False suspend = False pending_refresh = False screensaver = None progress_updates = None total_updates = 0 def __init__(self, monitor): self.direct_path = settings("useDirectPaths") == "1" self.progress_display = int(settings("syncProgress") or 50) self.monitor = monitor self.player = monitor.monitor.player self.server = Jellyfin().get_client() self.updated_queue = queue.Queue() self.userdata_queue = queue.Queue() self.removed_queue = queue.Queue() self.updated_output = self.__new_queues__() self.userdata_output = self.__new_queues__() self.removed_output = self.__new_queues__() self.notify_output = queue.Queue() self.jellyfin_threads = [] self.download_threads = [] self.notify_threads = [] self.writer_threads = {"updated": [], "userdata": [], "removed": []} self.database_lock = threading.Lock() self.music_database_lock = threading.Lock() threading.Thread.__init__(self) def __new_queues__(self): return { "Movie": queue.Queue(), "BoxSet": queue.Queue(), "MusicVideo": queue.Queue(), "Series": queue.Queue(), "Season": queue.Queue(), "Episode": queue.Queue(), "MusicAlbum": queue.Queue(), "MusicArtist": queue.Queue(), "AlbumArtist": queue.Queue(), "Audio": queue.Queue(), } def run(self): LOG.info("--->[ library ]") if not self.startup(): self.stop_client() window("jellyfin_startup.bool", True) while not self.stop_thread: try: self.service() except LibraryException: break except Exception as error: LOG.exception(error) break if self.monitor.waitForAbort(2): break LOG.info("---<[ library ]") def test_databases(self): """Open the databases to test if the file exists.""" with Database("video"), Database("music"): pass def check_version(self): """ Checks database version and triggers any required data migrations """ with Database("jellyfin") as jellyfindb: db = jellyfin_db.JellyfinDatabase(jellyfindb.cursor) db_version = db.get_version() if not db_version: # Make sure we always have a version in the database db.add_version((TARGET_DB_VERSION)) # Video Database Migrations with Database("video") as videodb: vid_db = KodiDb(videodb.cursor) if vid_db.migrations(): LOG.info("changes detected, reloading skin") xbmc.executebuiltin("UpdateLibrary(video)") xbmc.executebuiltin("ReloadSkin()") @stop def service(self): """If error is encountered, it will rerun this function. Start new "daemon threads" to process library updates. (actual daemon thread is not supported in Kodi) """ self.download_threads = [ thread for thread in self.download_threads if not thread.is_done ] self.writer_threads["updated"] = [ thread for thread in self.writer_threads["updated"] if not thread.is_done ] self.writer_threads["userdata"] = [ thread for thread in self.writer_threads["userdata"] if not thread.is_done ] self.writer_threads["removed"] = [ thread for thread in self.writer_threads["removed"] if not thread.is_done ] if ( not self.player.isPlayingVideo() or settings("syncDuringPlay.bool") or xbmc.getCondVisibility("VideoPlayer.Content(livetv)") ): self.worker_downloads() self.worker_sort() self.worker_updates() self.worker_userdata() self.worker_remove() self.worker_notify() if self.pending_refresh: window("jellyfin_sync.bool", True) if self.total_updates > self.progress_display: queue_size = self.worker_queue_size() if self.progress_updates is None: self.progress_updates = xbmcgui.DialogProgressBG() self.progress_updates.create( translate("addon_name"), translate(33178) ) self.progress_updates.update( int( ( float(self.total_updates - queue_size) / float(self.total_updates) ) * 100 ), message="%s: %s" % (translate(33178), queue_size), ) elif queue_size: self.progress_updates.update( int( ( float(self.total_updates - queue_size) / float(self.total_updates) ) * 100 ), message="%s: %s" % (translate(33178), queue_size), ) else: self.progress_updates.update( int( ( float(self.total_updates - queue_size) / float(self.total_updates) ) * 100 ), message=translate(33178), ) if not settings("dbSyncScreensaver.bool") and self.screensaver is None: xbmc.executebuiltin("InhibitIdleShutdown(true)") self.screensaver = get_screensaver() set_screensaver(value="") if ( self.pending_refresh and not self.download_threads and not self.writer_threads["updated"] and not self.writer_threads["userdata"] and not self.writer_threads["removed"] ): self.pending_refresh = False self.save_last_sync() self.total_updates = 0 window("jellyfin_sync", clear=True) if self.progress_updates: self.progress_updates.close() self.progress_updates = None if not settings("dbSyncScreensaver.bool") and self.screensaver is not None: xbmc.executebuiltin("InhibitIdleShutdown(false)") set_screensaver(value=self.screensaver) self.screensaver = None if xbmc.getCondVisibility( "Container.Content(musicvideos)" ): # Prevent cursor from moving xbmc.executebuiltin("Container.Refresh") else: # Update widgets xbmc.executebuiltin("UpdateLibrary(video)") if xbmc.getCondVisibility("Window.IsMedia"): xbmc.executebuiltin("Container.Refresh") def stop_client(self): self.stop_thread = True def enable_pending_refresh(self): """When there's an active thread. Let the main thread know.""" self.pending_refresh = True window("jellyfin_sync.bool", True) def worker_queue_size(self): """Get how many items are queued up for worker threads.""" total = 0 for queues in self.updated_output: total += self.updated_output[queues].qsize() for queues in self.userdata_output: total += self.userdata_output[queues].qsize() for queues in self.removed_output: total += self.removed_output[queues].qsize() return total def worker_downloads(self): """Get items from jellyfin and place them in the appropriate queues.""" for work_queue in ( (self.updated_queue, self.updated_output), (self.userdata_queue, self.userdata_output), ): if work_queue[0].qsize() and len(self.download_threads) < DTHREADS: new_thread = GetItemWorker(self.server, work_queue[0], work_queue[1]) new_thread.start() LOG.info("-->[ q:download/%s ]", id(new_thread)) self.download_threads.append(new_thread) def worker_sort(self): """Get items based on the local jellyfin database and place item in appropriate queues.""" if self.removed_queue.qsize() and len(self.jellyfin_threads) < 2: new_thread = SortWorker(self.removed_queue, self.removed_output) new_thread.start() LOG.info("-->[ q:sort/%s ]", id(new_thread)) def worker_updates(self): """Update items in the Kodi database.""" for queues in self.updated_output: queue = self.updated_output[queues] if queue.qsize() and not len(self.writer_threads["updated"]): if queues in ("Audio", "MusicArtist", "AlbumArtist", "MusicAlbum"): new_thread = UpdateWorker( queue, self.notify_output, self.music_database_lock, "music", self.server, self.direct_path, ) else: new_thread = UpdateWorker( queue, self.notify_output, self.database_lock, "video", self.server, self.direct_path, ) new_thread.start() LOG.info("-->[ q:updated/%s/%s ]", queues, id(new_thread)) self.writer_threads["updated"].append(new_thread) self.enable_pending_refresh() def worker_userdata(self): """Update userdata in the Kodi database.""" for queues in self.userdata_output: queue = self.userdata_output[queues] if queue.qsize() and not len(self.writer_threads["userdata"]): if queues in ("Audio", "MusicArtist", "AlbumArtist", "MusicAlbum"): new_thread = UserDataWorker( queue, self.music_database_lock, "music", self.server, self.direct_path, ) else: new_thread = UserDataWorker( queue, self.database_lock, "video", self.server, self.direct_path, ) new_thread.start() LOG.info("-->[ q:userdata/%s/%s ]", queues, id(new_thread)) self.writer_threads["userdata"].append(new_thread) self.enable_pending_refresh() def worker_remove(self): """Remove items from the Kodi database.""" for queues in self.removed_output: queue = self.removed_output[queues] if queue.qsize() and not len(self.writer_threads["removed"]): if queues in ("Audio", "MusicArtist", "AlbumArtist", "MusicAlbum"): new_thread = RemovedWorker( queue, self.music_database_lock, "music", self.server, self.direct_path, ) else: new_thread = RemovedWorker( queue, self.database_lock, "video", self.server, self.direct_path, ) new_thread.start() LOG.info("-->[ q:removed/%s/%s ]", queues, id(new_thread)) self.writer_threads["removed"].append(new_thread) self.enable_pending_refresh() def worker_notify(self): """Notify the user of new additions.""" if self.notify_output.qsize() and not len(self.notify_threads): new_thread = NotifyWorker(self.notify_output, self.player) new_thread.start() LOG.info("-->[ q:notify/%s ]", id(new_thread)) self.notify_threads.append(new_thread) def startup(self): """Run at startup. Check databases. Check for the server plugin. """ self.test_databases() self.check_version() Views().get_views() Views().get_nodes() try: if get_sync()["Libraries"]: try: with FullSync(self, self.server) as sync: sync.libraries() Views().get_nodes() except Exception as error: LOG.exception(error) elif not settings("SyncInstallRunDone.bool"): with FullSync(self, self.server) as sync: sync.libraries() Views().get_nodes() return True if settings("SyncInstallRunDone.bool") and settings("kodiCompanion.bool"): # None == Unknown if self.server.jellyfin.check_companion_enabled() is not False: if not self.fast_sync(): dialog("ok", "{jellyfin}", translate(33128)) raise Exception("Failed to retrieve latest updates") LOG.info("--<[ retrieve changes ]") # is False else: dialog("ok", "{jellyfin}", translate(33099)) settings("kodiCompanion.bool", False) return True return True except LibraryException as error: LOG.error(error.status) if error.status in "SyncLibraryLater": dialog("ok", "{jellyfin}", translate(33129)) settings("SyncInstallRunDone.bool", True) sync = get_sync() sync["Libraries"] = [] save_sync(sync) return True except Exception as error: LOG.exception(error) return False def fast_sync(self): """Movie and userdata not provided by server yet.""" last_sync = settings("LastIncrementalSync") include = [] filters = ["tvshows", "boxsets", "musicvideos", "music", "movies"] sync = get_sync() whitelist = [x.replace("Mixed:", "") for x in sync["Whitelist"]] LOG.info("--[ retrieve changes ] %s", last_sync) # Get the item type of each synced library and build list of types to request for item_id in whitelist: library = self.server.jellyfin.get_item(item_id) library_type = library.get("CollectionType") if library_type in filters: include.append(library_type) # Include boxsets if movies are synced if "movies" in include: include.append("boxsets") # Filter down to the list of library types we want to exclude query_filter = list(set(filters) - set(include)) try: # Get list of updates from server for synced library types and populate work queues result = self.server.jellyfin.get_sync_queue( last_sync, ",".join([x for x in query_filter]) ) if result is None: return True updated = [] userdata = [] removed = [] updated.extend(result["ItemsAdded"]) updated.extend(result["ItemsUpdated"]) userdata.extend(result["UserDataChanged"]) removed.extend(result["ItemsRemoved"]) total = len(updated) + len(userdata) if total > int(settings("syncIndicator") or 99): """Inverse yes no, in case the dialog is forced closed by Kodi.""" if dialog( "yesno", "{jellyfin}", translate(33172).replace("{number}", str(total)), nolabel=translate(107), yeslabel=translate(106), ): LOG.warning("Large updates skipped.") return True self.updated(updated) self.userdata(userdata) self.removed(removed) except Exception as error: LOG.exception(error) return False return True def save_last_sync(self): try: time_now = datetime.strptime( self.server.config.data["server-time"].split(", ", 1)[1], "%d %b %Y %H:%M:%S GMT", ) - timedelta(minutes=2) except Exception as error: LOG.exception(error) time_now = datetime.utcnow() - timedelta(minutes=2) last_sync = time_now.strftime("%Y-%m-%dT%H:%M:%Sz") settings("LastIncrementalSync", value=last_sync) LOG.info("--[ sync/%s ]", last_sync) def select_libraries(self, mode=None): """Select from libraries synced. Either update or repair libraries. Send event back to service.py """ modes = { "SyncLibrarySelection": "SyncLibrary", "RepairLibrarySelection": "RepairLibrary", "AddLibrarySelection": "SyncLibrary", "RemoveLibrarySelection": "RemoveLibrary", } sync = get_sync() whitelist = [x.replace("Mixed:", "") for x in sync["Whitelist"]] libraries = [] with Database("jellyfin") as jellyfindb: db = jellyfin_db.JellyfinDatabase(jellyfindb.cursor) if mode in ( "SyncLibrarySelection", "RepairLibrarySelection", "RemoveLibrarySelection", ): for library in sync["Whitelist"]: name = db.get_view_name(library.replace("Mixed:", "")) libraries.append({"Id": library, "Name": name}) else: available = [x for x in sync["SortedViews"] if x not in whitelist] for library in available: view = db.get_view(library) if view.media_type in ( "movies", "tvshows", "musicvideos", "mixed", "music", ): libraries.append({"Id": view.view_id, "Name": view.view_name}) choices = [x["Name"] for x in libraries] choices.insert(0, translate(33121)) titles = { "RepairLibrarySelection": 33199, "SyncLibrarySelection": 33198, "RemoveLibrarySelection": 33200, "AddLibrarySelection": 33120, } title = titles.get(mode, "Failed to get title {}".format(mode)) selection = dialog("multi", translate(title), choices) if selection is None: return if 0 in selection: selection = list(range(1, len(libraries) + 1)) selected_libraries = [] for x in selection: library = libraries[x - 1] selected_libraries.append(library["Id"]) event( modes[mode], { "Id": ",".join([libraries[x - 1]["Id"] for x in selection]), "Update": mode == "SyncLibrarySelection", }, ) def add_library(self, library_id, update=False): try: with FullSync(self, server=self.server) as sync: sync.libraries(library_id, update) except Exception as error: LOG.exception(error) return False Views().get_nodes() return True def remove_library(self, library_id): try: with FullSync(self, self.server) as sync: sync.remove_library(library_id) Views().remove_library(library_id) except Exception as error: LOG.exception(error) return False Views().get_views() Views().get_nodes() return True def userdata(self, data): """Add item_id to userdata queue.""" if not data: return items = [x["ItemId"] for x in data] for item in split_list(items, LIMIT): self.userdata_queue.put(item) self.total_updates += len(items) LOG.info("---[ userdata:%s ]", len(items)) def updated(self, data): """Add item_id to updated queue.""" if not data: return for item in split_list(data, LIMIT): self.updated_queue.put(item) self.total_updates += len(data) LOG.info("---[ updated:%s ]", len(data)) def removed(self, data): """Add item_id to removed queue.""" if not data: return for item in data: if item in list(self.removed_queue.queue): continue self.removed_queue.put(item) self.total_updates += len(data) LOG.info("---[ removed:%s ]", len(data)) class UpdateWorker(threading.Thread): is_done = False def __init__( self, queue, notify, lock, database, server=None, direct_path=None, *args ): self.queue = queue self.notify_output = notify self.notify = settings("newContent.bool") self.lock = lock self.database = Database(database) self.args = args self.server = server self.direct_path = direct_path threading.Thread.__init__(self) def run(self): with self.lock, self.database as kodidb, Database("jellyfin") as jellyfindb: default_args = (self.server, jellyfindb, kodidb, self.direct_path) if kodidb.db_file == "video": movies = Movies(*default_args) tvshows = TVShows(*default_args) musicvideos = MusicVideos(*default_args) elif kodidb.db_file == "music": music = Music(*default_args) else: # this should not happen LOG.error( '"{}" is not a valid Kodi library type.'.format(kodidb.db_file) ) return while True: try: item = self.queue.get(timeout=1) except queue.Empty: break try: LOG.debug("{} - {}".format(item["Type"], item["Name"])) if item["Type"] == "Movie": movies.movie(item) elif item["Type"] == "BoxSet": movies.boxset(item) elif item["Type"] == "Series": tvshows.tvshow(item) elif item["Type"] == "Season": tvshows.season(item) elif item["Type"] == "Episode": tvshows.episode(item) elif item["Type"] == "MusicVideo": musicvideos.musicvideo(item) elif item["Type"] == "MusicAlbum": music.album(item) elif item["Type"] == "MusicArtist": music.artist(item) elif item["Type"] == "AlbumArtist": music.albumartist(item) elif item["Type"] == "Audio": music.song(item) if self.notify: self.notify_output.put( (item["Type"], api.API(item).get_naming()) ) except LibraryException as error: if error.status == "StopCalled": break except Exception as error: LOG.exception(error) self.queue.task_done() if window("jellyfin_should_stop.bool"): break LOG.info("--<[ q:updated/%s ]", id(self)) self.is_done = True class UserDataWorker(threading.Thread): is_done = False def __init__(self, queue, lock, database, server, direct_path): self.queue = queue self.lock = lock self.database = Database(database) self.server = server self.direct_path = direct_path threading.Thread.__init__(self) def run(self): with self.lock, self.database as kodidb, Database("jellyfin") as jellyfindb: default_args = (self.server, jellyfindb, kodidb, self.direct_path) if kodidb.db_file == "video": movies = Movies(*default_args) tvshows = TVShows(*default_args) elif kodidb.db_file == "music": music = Music(*default_args) else: # this should not happen LOG.error( '"{}" is not a valid Kodi library type.'.format(kodidb.db_file) ) return while True: try: item = self.queue.get(timeout=1) except queue.Empty: break try: if item["Type"] == "Movie": movies.userdata(item) elif item["Type"] in ["Series", "Season", "Episode"]: tvshows.userdata(item) elif item["Type"] == "MusicAlbum": music.album(item) elif item["Type"] == "MusicArtist": music.artist(item) elif item["Type"] == "AlbumArtist": music.albumartist(item) elif item["Type"] == "Audio": music.userdata(item) except LibraryException as error: if error.status == "StopCalled": break except Exception as error: LOG.exception(error) self.queue.task_done() if window("jellyfin_should_stop.bool"): break LOG.info("--<[ q:userdata/%s ]", id(self)) self.is_done = True class SortWorker(threading.Thread): is_done = False def __init__(self, queue, output, *args): self.queue = queue self.output = output self.args = args threading.Thread.__init__(self) def run(self): with Database("jellyfin") as jellyfindb: database = jellyfin_db.JellyfinDatabase(jellyfindb.cursor) while True: try: item_id = self.queue.get(timeout=1) except queue.Empty: break try: media = database.get_media_by_id(item_id) if media: self.output[media].put({"Id": item_id, "Type": media}) else: items = database.get_media_by_parent_id(item_id) if not items: LOG.info( "Could not find media %s in the jellyfin database.", item_id, ) else: for item in items: self.output[item[1]].put( {"Id": item[0], "Type": item[1]} ) except Exception as error: LOG.exception(error) self.queue.task_done() if window("jellyfin_should_stop.bool"): break LOG.info("--<[ q:sort/%s ]", id(self)) self.is_done = True class RemovedWorker(threading.Thread): is_done = False def __init__(self, queue, lock, database, server, direct_path): self.queue = queue self.lock = lock self.database = Database(database) self.server = server self.direct_path = direct_path threading.Thread.__init__(self) def run(self): with self.lock, self.database as kodidb, Database("jellyfin") as jellyfindb: default_args = (self.server, jellyfindb, kodidb, self.direct_path) if kodidb.db_file == "video": movies = Movies(*default_args) tvshows = TVShows(*default_args) musicvideos = MusicVideos(*default_args) elif kodidb.db_file == "music": music = Music(*default_args) else: # this should not happen LOG.error( '"{}" is not a valid Kodi library type.'.format(kodidb.db_file) ) return while True: try: item = self.queue.get(timeout=1) except queue.Empty: break if item["Type"] == "Movie": obj = movies.remove elif item["Type"] in ["Series", "Season", "Episode"]: obj = tvshows.remove elif item["Type"] in [ "MusicAlbum", "MusicArtist", "AlbumArtist", "Audio", ]: obj = music.remove elif item["Type"] == "MusicVideo": obj = musicvideos.remove try: obj(item["Id"]) except LibraryException as error: if error.status == "StopCalled": break except Exception as error: LOG.exception(error) finally: self.queue.task_done() if window("jellyfin_should_stop.bool"): break LOG.info("--<[ q:removed/%s ]", id(self)) self.is_done = True class NotifyWorker(threading.Thread): is_done = False def __init__(self, queue, player): self.queue = queue self.video_time = int(settings("newvideotime")) * 1000 self.music_time = int(settings("newmusictime")) * 1000 self.player = player threading.Thread.__init__(self) def run(self): while True: try: item = self.queue.get(timeout=3) except queue.Empty: break time = self.music_time if item[0] == "Audio" else self.video_time if time and ( not self.player.isPlayingVideo() or xbmc.getCondVisibility("VideoPlayer.Content(livetv)") ): dialog( "notification", heading="%s %s" % (translate(33049), item[0]), message=item[1], icon="{jellyfin}", time=time, sound=False, ) self.queue.task_done() if window("jellyfin_should_stop.bool"): break LOG.info("--<[ q:notify/%s ]", id(self)) self.is_done = True