91 lines
3.9 KiB
Python
91 lines
3.9 KiB
Python
import pyinotify
|
|
|
|
from media.monitor.log import Loggable
|
|
from media.monitor.listeners import StoreWatchListener, OrganizeListener
|
|
from media.monitor.organizer import Organizer
|
|
|
|
class Manager(Loggable):
|
|
"""
|
|
An abstraction over media monitors core pyinotify functions. These include
|
|
adding watched,store, organize directories, etc. Basically composes over
|
|
WatchManager from pyinotify
|
|
"""
|
|
all_signals = set(['add_watch', 'remove_watch'])
|
|
# TODO : get rid of config object being passed? It's not actually being
|
|
# used
|
|
def __init__(self,config):
|
|
|
|
self.wm = pyinotify.WatchManager()
|
|
# These two instance variables are assumed to be constant
|
|
self.watch_channel = 'watch'
|
|
self.organize_channel = 'organize'
|
|
|
|
self.watch_listener = StoreWatchListener(self.watch_channel)
|
|
|
|
self.organize = {
|
|
'organize_path' : None,
|
|
'store_path' : None,
|
|
# This guy doesn't need to be changed, always the same.
|
|
# Gets hooked by wm to different directories
|
|
'organize_listener' : OrganizeListener(self.organize_channel),
|
|
# Also stays the same as long as its target, the directory
|
|
# which the "organized" files go to, isn't changed.
|
|
'organizer' : None,
|
|
}
|
|
|
|
self.watched_directories = set([])
|
|
|
|
def __remove_watch(self,path):
|
|
old_watch = self.wm.get_wd(path)
|
|
if old_watch: # only delete if dir is actually being watched
|
|
self.rm_watch(old_watch, rec=True)
|
|
|
|
def __create_organizer(self, target_path):
|
|
return Organizer(channel=self.organize_channel,target_path=target_path)
|
|
|
|
def set_organize_path(self, new_path):
|
|
# if we are already organizing a particular directory we remove the
|
|
# watch from it first before organizing another directory
|
|
self.__remove_watch(self.organize['organize_path'])
|
|
self.organize['organize_path'] = new_path
|
|
# the OrganizeListener instance will walk path and dispatch an organize
|
|
# event for every file in that directory
|
|
self.organize['organize_listener'].flush_events(new_path)
|
|
self.wm.add_watch(new_path, pyinotify.ALL_EVENTS, rec=True, auto_add=True,
|
|
proc_fun=self.organize['organize_listener'])
|
|
|
|
def set_store_path(self,new_path):
|
|
"""set the directory where organized files go to"""
|
|
self.__remove_watch(self.organize['store_path'])
|
|
self.organize['store_path'] = new_path
|
|
self.organize['organizer'] = self.__create_organizer(new_path)
|
|
# flush all the files in the new store_directory. this is done so that
|
|
# new files are added to the database. Note that we are not responsible
|
|
# for removing songs in the old store directory from the database
|
|
# we assume that this is already done for us.
|
|
self.watch_listener.flush_events(new_path)
|
|
self.wm.add_watch(new_path, pyinotify.ALL_EVENTS, rec=True, auto_add=True,
|
|
proc_fun=self.watch_listener)
|
|
|
|
def add_watch_directory(self, new_dir):
|
|
if new_dir in self.watched_directories:
|
|
self.logger.info("Cannot add '%s' to watched directories. It's \
|
|
already being watched" % new_dir)
|
|
else:
|
|
self.logger.info("Adding watched directory: '%s'" % new_dir)
|
|
self.watched_directories.add(new_dir)
|
|
self.wm.add_watch(new_dir, pyinotify.ALL_EVENTS, rec=True, auto_add=True,
|
|
proc_fun=self.watch_listener)
|
|
|
|
def remove_watch_directory(self, watch_dir):
|
|
if watch_dir in self.watched_directories:
|
|
self.watched_directories.remove(watch_dir)
|
|
self.logger.info("Removing watched directory: '%s'", watch_dir)
|
|
self.__remove_watch(watch_dir)
|
|
else:
|
|
self.logger.info("'%s' is not being watched, henced cannot be removed"
|
|
% watch_dir)
|
|
|
|
def loop(self):
|
|
pyinotify.Notifier(self.wm).loop()
|