def core_main_init(options=None, args=None):
'''
Part of the main function prior to the UI initialization.
'''
# Debugging subsystem initialization
if options.debug:
Log.setLevel(logging.DEBUG)
Log.debug("Debug output enabled.")
else:
Log.setLevel(logging.INFO)
Log.set_debugging_mode(options.debug)
config = CoreConfig()
check_instance(config.get_data_dir(), args)
backends_list = BackendFactory().get_saved_backends_list()
# Load data store
ds = DataStore(config)
# Register backends
for backend_dic in backends_list:
ds.register_backend(backend_dic)
# save the backends directly to be sure projects.xml is written
ds.save(quit=False)
# Launch task browser
req = ds.get_requester()
return ds, req
def core_main_init(options=None, args=None):
'''
Part of the main function prior to the UI initialization.
'''
# Debugging subsystem initialization
if options.debug:
Log.setLevel(logging.DEBUG)
Log.debug("Debug output enabled.")
else:
Log.setLevel(logging.INFO)
Log.set_debugging_mode(options.debug)
config = CoreConfig()
check_instance(config.get_data_dir(), args)
backends_list = BackendFactory().get_saved_backends_list()
# Load data store
ds = DataStore(config)
# Register backends
for backend_dic in backends_list:
ds.register_backend(backend_dic)
# save the backends directly to be sure projects.xml is written
ds.save(quit=False)
# Launch task browser
req = ds.get_requester()
return ds, req
def __init__(self, global_conf=CoreConfig()):
"""
Initializes a DataStore object
"""
# dictionary {backend_name_string: Backend instance}
self.backends = {}
self.treefactory = TreeFactory()
self._tasks = self.treefactory.get_tasks_tree()
self.requester = requester.Requester(self, global_conf)
self.tagfile = None
self._tagstore = self.treefactory.get_tags_tree(self.requester)
self.load_tag_tree()
self._backend_signals = BackendSignals()
# Flag when turned to true, all pending operation should be
# completed and then GTG should quit
self.please_quit = False
# The default backend must be loaded first. This flag turns to True
# when the default backend loading has finished.
self.is_default_backend_loaded = False
self._backend_signals.connect('default-backend-loaded',
self._activate_non_default_backends)
self.filtered_datastore = FilteredDataStore(self)
self._backend_mutex = threading.Lock()
def load_tag_tree(self):
"""
Loads the tag tree from a xml file
"""
tagfile = os.path.join(CoreConfig().get_data_dir(), TAG_XMLFILE)
doc, xmlstore = cleanxml.openxmlfile(tagfile, TAG_XMLROOT)
for t in xmlstore.childNodes:
tagname = t.getAttribute("name")
parent = t.getAttribute("parent")
tag_attr = {}
attr = t.attributes
for i in range(attr.length):
at_name = attr.item(i).name
if at_name not in ["name", "parent"]:
at_val = t.getAttribute(at_name)
tag_attr[at_name] = at_val
if parent == CoreConfig.SEARCH_TAG:
query = t.getAttribute("query")
tag = self.new_search_tag(tagname, query, tag_attr)
else:
tag = self.new_tag(tagname, tag_attr)
if parent:
tag.set_parent(parent)
self.tagfile = tagfile
def _configure_icon_theme(self):
'''
Inform gtk on the location of the backends icons (which is in
the GTG directory tree, and not in the default location for icons
'''
self.icon_theme = Gtk.IconTheme.get_default()
for directory in CoreConfig().get_icons_directories():
self.icon_theme.prepend_search_path(directory)
def get_path(self):
"""
Return the current path to XML
Path can be relative to projects.xml
"""
path = self._parameters["path"]
if os.sep not in path:
# Local path
data_dir = CoreConfig().get_data_dir()
path = os.path.join(data_dir, path)
return os.path.abspath(path)
def _store_pickled_file(self, path, data):
'''
A helper function to save some object in a file.
@param path: a relative path. A good choice is
"backend_name/object_name"
@param data: the object
'''
path = os.path.join(CoreConfig().get_data_dir(), path)
# mkdir -p
try:
os.makedirs(os.path.dirname(path))
except OSError, exception:
if exception.errno != errno.EEXIST:
raise
def _read_backend_configuration_file(self):
'''
Reads the file describing the current backend configuration
(project.xml) and returns a list of dictionaries, each containing:
- the xml object defining the backend characteristics under
"xmlobject"
- the name of the backend under "module"
'''
# Read configuration file, if it does not exist, create one
datafile = os.path.join(CoreConfig().get_data_dir(),
CoreConfig.DATA_FILE)
doc, configxml = cleanxml.openxmlfile(datafile, "config")
xmlproject = doc.getElementsByTagName("backend")
# collect configured backends
return [{"xmlobject": xp,
"module": xp.getAttribute("module")} for xp in xmlproject]
def save(self, quit=False):
"""
Saves the backends parameters.
@param quit: If quit is true, backends are shut down
"""
try:
self.start_get_tasks_thread.join()
except Exception:
pass
doc, xmlconfig = cleanxml.emptydoc("config")
# we ask all the backends to quit first.
if quit:
# we quit backends in parallel
threads_dic = {}
for b in self.get_all_backends():
thread = threading.Thread(target=b.quit)
threads_dic[b.get_id()] = thread
thread.start()
for backend_id, thread in threads_dic.iteritems():
# after 20 seconds, we give up
thread.join(20)
if thread.isAlive():
Log.error("The %s backend stalled while quitting",
backend_id)
# we save the parameters
for b in self.get_all_backends(disabled=True):
t_xml = doc.createElement("backend")
for key, value in b.get_parameters().iteritems():
if key in ["backend", "xmlobject"]:
# We don't want parameters, backend, xmlobject:
# we'll create them at next startup
continue
param_type = b.get_parameter_type(key)
value = b.cast_param_type_to_string(param_type, value)
t_xml.setAttribute(str(key), value)
# Saving all the projects at close
xmlconfig.appendChild(t_xml)
datadir = CoreConfig().get_data_dir()
datafile = os.path.join(datadir, CoreConfig.DATA_FILE)
cleanxml.savexml(datafile, doc, backup=True)
# Saving the tagstore
self.save_tagtree()
def _load_pickled_file(self, path, default_value=None):
'''
A helper function to load some object from a file.
@param path: the relative path of the file
@param default_value: the value to return if the file is missing or
corrupt
@returns object: the needed object, or default_value
'''
path = os.path.join(CoreConfig().get_data_dir(), path)
if not os.path.exists(path):
return default_value
with open(path, 'r') as file:
try:
return pickle.load(file)
except Exception:
Log.error("Pickle file for backend '%s' is damaged" %
self.get_name())
# Loading file failed, trying backups
for i in range(1, PICKLE_BACKUP_NBR + 1):
backup_file = "%s.bak.%d" % (path, i)
if os.path.exists(backup_file):
with open(backup_file, 'r') as file:
try:
data = pickle.load(file)
Log.info("Succesfully restored backup #%d for '%s'" %
(i, self.get_name()))
return data
except Exception:
Log.error("Backup #%d for '%s' is damaged as well" %
(i, self.get_name()))
# Data could not be loaded, degrade to default data
Log.error("There is no suitable backup for '%s', "
"loading default data" % self.get_name())
return default_value
def _store_pickled_file(self, path, data):
'''
A helper function to save some object in a file.
@param path: a relative path. A good choice is
"backend_name/object_name"
@param data: the object
'''
path = os.path.join(CoreConfig().get_data_dir(), path)
# mkdir -p
try:
os.makedirs(os.path.dirname(path))
except OSError as exception:
if exception.errno != errno.EEXIST:
raise
# Shift backups
for i in range(PICKLE_BACKUP_NBR, 1, -1):
destination = "%s.bak.%d" % (path, i)
source = "%s.bak.%d" % (path, i - 1)
if os.path.exists(destination):
os.unlink(destination)
if os.path.exists(source):
os.rename(source, destination)
# Backup main file
if PICKLE_BACKUP_NBR > 0:
destination = "%s.bak.1" % path
if os.path.exists(path):
os.rename(path, destination)
# saving
with open(path, 'wb') as file:
pickle.dump(data, file)
def SetUp(self):
CoreConfig().set_data_dir("./test_data")
CoreConfig().set_conf_dir("./test_data")