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),
}