def migrate(force=False):
if not force and not migration_needed():
logger.debug("Will not migrate and overwrite data.")
return
logger.info("Migrating data from 0.2.14....")
# allow force to overwrite the new db
newdbpath = os.path.join(xdg.get_data_dirs()[0], 'music.db')
if os.path.exists(newdbpath):
os.remove(newdbpath)
oldsettings = SafeConfigParser()
oldsettings.read(os.path.expanduser('~/.exaile/settings.ini'))
if not olddb.SQLITE_AVAIL:
raise MigrationException("Sqlite is not available. "
"Unable to migrate 0.2.14 settings")
# old database
db = olddb.DBManager(os.path.expanduser('~/.exaile/music.db'), False)
# new database
newdb = collection.Collection('tdb', os.path.join(xdg.get_data_dirs()[0],
'music.db'))
_migrate_old_tracks(oldsettings, db, newdb)
_migrate_old_settings(oldsettings)
settings.MANAGER.save()
playlists = PlaylistManager()
_migrate_playlists(db, newdb, playlists)
logger.info("Migration complete!")
def __init__(self, parent, library, mgr):
"""
Expects a parent Gtk.Window, and a daap connection.
"""
self.name = library.daap_share.name
self.daap_share = library.daap_share
self.net_collection = collection.Collection(self.name)
self.net_collection.add_library(library)
CollectionPanel.__init__(self, parent, self.net_collection,
self.name, _show_collection_empty_message=False)
self.all = []
self.label = self.name
self.connect_id = None
self.menu = menu.Menu(self)
def get_tracks_func(*args):
return self.tree.get_selected_tracks()
self.menu.add_item(menuitems.AppendMenuItem('append', [],
get_tracks_func))
self.menu.add_item(menuitems.EnqueueMenuItem('enqueue', ['append'],
get_tracks_func))
self.menu.add_item(menuitems.PropertiesMenuItem('props', ['enqueue'],
get_tracks_func))
self.menu.add_item(_sep('sep',['props']))
self.menu.add_item(_smi('refresh', ['sep'], _('Refresh Server List'),
callback = lambda *x: mgr.refresh_share(self.name)))
self.menu.add_item(_smi('disconnect', ['refresh'],
_('Disconnect from Server'),
callback = lambda *x: mgr.disconnect_share(self.name)))
def __init__(self, name):
self.name = name
self.collection = collection.Collection(name=self.name)
self.playlists = []
self._connected = False
self.transfer = None # subclasses need to override this
def __init(self):
"""
Initializes Exaile
"""
# pylint: disable-msg=W0201
logger.info("Loading Exaile %s on Python %s..." %
(__version__, platform.python_version()))
logger.info("Loading settings...")
try:
from xl import settings
except common.VersionError:
logger.exception("Error loading settings")
sys.exit(1)
logger.debug("Settings loaded from %s" % settings.location)
# display locale information if available
try:
import locale
lc, enc = locale.getlocale()
if enc is not None:
logger.info("Using %s %s locale" % (lc, enc))
else:
logger.info("Using unknown locale")
except Exception:
pass
splash = None
if self.options.StartGui:
if settings.get_option('gui/use_splash', True):
from xlgui.widgets.info import Splash
splash = Splash()
splash.show()
firstrun = settings.get_option("general/first_run", True)
if not self.options.NoImport and \
(firstrun or self.options.ForceImport):
try:
sys.path.insert(0, xdg.get_data_path("migrations"))
import migration_200907100931 as migrator
del sys.path[0]
migrator.migrate(force=self.options.ForceImport)
del migrator
except Exception:
logger.exception("Failed to migrate from 0.2.14")
# Migrate old rating options
from xl.migrations.settings import rating
rating.migrate()
# Migrate builtin OSD to plugin
from xl.migrations.settings import osd
osd.migrate()
# Migrate engines
from xl.migrations.settings import engine
engine.migrate()
# TODO: enable audio plugins separately from normal
# plugins? What about plugins that use the player?
# Gstreamer doesn't initialize itself automatically, and fails
# miserably when you try to inherit from something and GST hasn't
# been initialized yet. So this is here.
from gi.repository import Gst
Gst.init(None)
# Initialize plugin manager
from xl import plugins
self.plugins = plugins.PluginsManager(self)
if not self.options.SafeMode:
logger.info("Loading plugins...")
self.plugins.load_enabled()
else:
logger.info("Safe mode enabled, not loading plugins.")
# Initialize the collection
logger.info("Loading collection...")
from xl import collection
try:
self.collection = collection.Collection("Collection",
location=os.path.join(
xdg.get_data_dir(),
'music.db'))
except common.VersionError:
logger.exception("VersionError loading collection")
sys.exit(1)
from xl import event
# Set up the player and playback queue
from xl import player
event.log_event("player_loaded", player.PLAYER, None)
# Initalize playlist manager
from xl import playlist
self.playlists = playlist.PlaylistManager()
self.smart_playlists = playlist.SmartPlaylistManager(
'smart_playlists', collection=self.collection)
if firstrun:
self._add_default_playlists()
event.log_event("playlists_loaded", self, None)
# Initialize dynamic playlist support
from xl import dynamic
dynamic.MANAGER.collection = self.collection
# Initalize device manager
logger.info("Loading devices...")
from xl import devices
self.devices = devices.DeviceManager()
event.log_event("device_manager_ready", self, None)
# Initialize dynamic device discovery interface
# -> if initialized and connected, then the object is not None
self.udisks2 = None
self.udisks = None
self.hal = None
if self.options.Hal:
from xl import hal
udisks2 = hal.UDisks2(self.devices)
if udisks2.connect():
self.udisks2 = udisks2
else:
udisks = hal.UDisks(self.devices)
if udisks.connect():
self.udisks = udisks
else:
self.hal = hal.HAL(self.devices)
self.hal.connect()
else:
self.hal = None
# Radio Manager
from xl import radio
self.stations = playlist.PlaylistManager('radio_stations')
self.radio = radio.RadioManager()
self.gui = None
# Setup GUI
if self.options.StartGui:
logger.info("Loading interface...")
import xlgui
self.gui = xlgui.Main(self)
self.gui.main.window.show_all()
event.log_event("gui_loaded", self, None)
if splash is not None:
splash.destroy()
if firstrun:
settings.set_option("general/first_run", False)
self.loading = False
Exaile._exaile = self
event.log_event("exaile_loaded", self, None)
restore = True
if self.gui:
# Find out if the user just passed in a list of songs
# TODO: find a better place to put this
songs = [
Gio.File.new_for_path(arg).get_uri()
for arg in self.options.locs
]
if len(songs) > 0:
restore = False
self.gui.open_uri(songs[0], play=True)
for arg in songs[1:]:
self.gui.open_uri(arg)
# kick off autoscan of libraries
# -> don't do it in command line mode, since that isn't expected
self.gui.rescan_collection_with_progress(True)
if restore:
player.QUEUE._restore_player_state(
os.path.join(xdg.get_data_dir(), 'player.state'))
def disconnect(self):
self.collection = collection.Collection(name=self.name)
self.mountpoints = []
self.transfer = None
self.connected = False
