def init(config): media_backend = config.get("general", "media_backend") if media_backend == "auto": backend_it = iter([DEFAULT_BACKEND] + AVAILABLE_BACKENDS) media_backend = None try: while not media_backend: backend = next(backend_it) try: backend_module = get_backend_module(backend) except ImportError: # Do nothing, simply ignore pass else: media_backend = backend config.set('general', 'mediabackend', backend) log.msg(_("Autodetected %s backend." % backend)) except StopIteration: log.err(_("Could not find suitable media backend."), fatal=True) elif media_backend in AVAILABLE_BACKENDS: backend_module = get_backend_module(media_backend) else: log.err(_("Invalid media backend %s" % media_backend), fatal=True) try: player_class = getattr(backend_module, '%sPlayer' % media_backend.capitalize()) player = player_class(config) except PlayerError as err: log.err(str(err), fatal=True) return player
def end_update(self, result=True): self.updating_state["running"] = False if result: log.msg(_("The %s library has been updated") % self.TYPE) self.dispatch_signame(self.UPDATE_SIGNAL_NAME) self.state["last_update"] = time.time() else: msg = _("Unable to update the %s library. See log.") % self.TYPE log.err(msg) self.updating_state["error"] = msg return True
def __init__(self, player, audio_library, video_library, config): super(SourceFactory, self).__init__() self.load_state() self.sources = { "audiopls": AudioSource(audio_library), "audioqueue": QueueSource(audio_library) } # Video if config.getboolean("video", "enabled"): self.sources["videopls"] = VideoSource(video_library) else: log.msg(_("Video support disabled")) if self.state["active"] not in self.sources: self.state["active"] = self.sources["audiopls"] player.set_source(self) player.load_state()
def init(uri, debug=False): global DatabaseLock repository = os.path.join(os.path.dirname(__file__), "dbmigrate") last_version = migrate.versioning.api.version(url=uri, repository=repository) # create engine based on config log.debug("Connection to database %s" % uri) engine = create_engine(uri, echo=debug) # know if table as instantiated inspector = Inspector.from_engine(engine) if not inspector.get_table_names(): log.msg("Create database tables...") # create table import deejayd.db.models base = deejayd.db.models.Base base.metadata.create_all(engine) # init migrate version to the last migrate.versioning.api.version_control(url=uri, repository=repository, version=last_version) else: try: vers = migrate.versioning.api.db_version(url=uri, repository=repository) except Exception: # set db_version to 0 migrate.versioning.api.version_control(url=uri, repository=repository, version=0) vers = 0 if vers < last_version: log.msg("Upgrade database schema to %d" % last_version) migrate.versioning.api.upgrade(url=uri, repository=repository) # configure scoped session and init lock Session.configure(bind=engine) DatabaseLock = uri.startswith("sqlite") and threading.Lock() or FakeLock()
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. from deejayd import DeejaydError from deejayd.ui import log from deejayd.library.audio import AudioLibrary from deejayd.library.video import VideoLibrary try: from deejayd.library import inotify except ImportError: log.msg("Inotify is not supported on this platform") inotify = None def init(player, config): audio_library, video_library, lib_watcher = None, None, None audio_dir = config.get("mediadb", "music_directory") try: audio_library = AudioLibrary(audio_dir) except DeejaydError as msg: log.err(_("Unable to init audio library : %s") % msg, fatal=True) if config.getboolean("video", "enabled"): video_dir = config.get('mediadb', 'video_directory') try:
def __reload_list(self): log.msg(_("Start to reload icecast webradio source")) url = DeejaydConfig().get("webradio", "icecast_url") try: page_handle = urllib.request.urlopen(url, timeout=TIMEOUT) xml_page = page_handle.read() except Exception: raise DeejaydError(_("Unable to connect to icecast website")) # try to parse result try: root = ET.fromstring(xml_page) except ET.XMLSyntaxError: raise DeejaydError(_("Unable to parse icecast webradio list")) except Exception: raise DeejaydError( _("Unable to read result from icecast " "webradio list")) finally: page_handle.close() DatabaseLock.acquire() session = Session() source = session.query(WebradioSource)\ .filter(WebradioSource.name == self.NAME)\ .one() # delete old entries from the database session.query(Webradio)\ .filter(Webradio.source_id == source.id)\ .delete(synchronize_session='fetch') session.query(WebradioCategory)\ .filter(WebradioCategory.source_id == source.id)\ .delete(synchronize_session='fetch') categories = {} webradios = {} for station in root: try: server_type = station.find("server_type").text listen_url = station.find("listen_url").text genres = station.find("genre").text name = station.find("server_name").text except TypeError: continue if server_type.startswith("audio") or \ (server_type == "application/ogg" and not listen_url.endswith("ogv")): if name not in webradios: genres = genres.split(" ") webradios[name] = Webradio(source=source, name=name) for genre in genres: if len(genre) <= 2 or genre.startswith("."): continue genre = genre.capitalize() if genre not in categories: categories[genre] = WebradioCategory(name=genre, source=source) webradios[name].categories.append(categories[genre]) session.add(webradios[name]) webradios[name].entries.append(WebradioEntry(url=listen_url)) log.debug('Added icecast webradio %s' % name) session.commit() Session.remove() DatabaseLock.release() log.msg(_("Finish to reload icecast webradio source")) return { "wb_count": len(webradios), "cat_count": len(categories), }