def create_options_widget(self, parent): from db_connections.DbConnOptions import DbConnOptions self._init_plugin_objects() self.conn_properties_lock.acquire() self.conn_options_widget = DbConnOptions(parent, self.conn_properties) self.conn_properties_lock.release() return self.conn_options_widget
class db_connections(iface_general_plugin): STANDARD_PLUGIN = "SQLite Connection" def __init__(self): super(db_connections, self).__init__() self.plugin_manager = get_plugin_manager() self.conn_properties_lock = loggingMutex("db_conn_properties", logging=get_settings().get_verbose()) self.open_connections = {} self.conn_properties = {} self.conn_plugins = {} #will be filled later (init plugin obejcts) self.options = [(("default_connection","Default Connection", self.conn_properties.keys(), get_settings().set_default_db_connection), get_settings().get_default_db_connection())] self.force_activation = True ''' lazy plugin loading (not to be called in __init__ - plugins might not be activated then) ''' def _init_plugin_objects(self): if len(self.conn_plugins)==0: self.conn_properties_lock.acquire() '''fill the only known property for now: the type of every connection and store the instance''' try: for conn_name in get_settings().get_available_db_connections(): section_name = "DB Connection: "+str(conn_name) plugin_type = self.STANDARD_PLUGIN plugin_type = get_settings().read_value_from_config_file(plugin_type, section_name, "plugin_type") p = self.plugin_manager.getPluginByName(plugin_type, "db") if p != None and p.plugin_object.is_activated: self.conn_plugins[conn_name] = p.plugin_object else: # TODO should this be a warning? self.logger.error("DB Connection %s requires plugin of type "\ "%s which is not available. \n Delete the connection from the Settings "\ "or install the DB plugin again.", conn_name, plugin_type) continue p_options = p.plugin_object.options.copy() for k,v in p_options.items(): '''this takes care of the option-type''' p_options[k] = get_settings().read_value_from_config_file(v, section_name, k) p_options["plugin_type"]=plugin_type self.conn_properties[conn_name] = p_options.copy() except: raise finally: self.conn_properties_lock.release() def getProperties(self, conn_id): self._init_plugin_objects() ob = self.conn_plugins[conn_id] with self.conn_properties_lock: prop = self.conn_properties[conn_id] assert("plugin_type" in prop) if len(prop)==1: prop = ob.options.copy() return ob,prop def deactivate(self): for name,conn in self.open_connections.iteritems(): try: conn.close(self.logger) except: self.logger.exception("While deactivating: Could not close connection %s", name) iface_general_plugin.deactivate(self) def getDBConnection(self, logger, name=""): """returns tuple (connection_handle, connection_type) of the given connection""" if len(name)==0: name = get_settings().get_default_db_connection() if name not in get_settings().get_available_db_connections(): return None, None ob, props = self.getProperties(name) if name not in self.open_connections: self.logger.debug("DB Connections: opening connection %s of type %s", name, props["plugin_type"]) self.open_connections[name] = ob.create_connection(props) return _LoggerWrapper(self.open_connections[name], logger), props["plugin_type"] def getConnectionType(self, _logger, name=""): """Returns the connection type for a given connection name.""" if not name: name = get_settings().get_default_db_connection() with self.conn_properties_lock: if name not in self.conn_properties: return None _ob, props = self.getProperties(name) return props["plugin_type"] def has_options_widget(self): return True def create_options_widget(self, parent): from db_connections.DbConnOptions import DbConnOptions self._init_plugin_objects() self.conn_properties_lock.acquire() self.conn_options_widget = DbConnOptions(parent, self.conn_properties) self.conn_properties_lock.release() return self.conn_options_widget def save_options_widget_data(self, **_kwargs): new_props = self.conn_options_widget.get_connection_properties() self.config_file = get_settings().get_config_file() '''@todo Delete connections here''' with self.conn_properties_lock: for conn_name, props in new_props.iteritems(): section_name = "DB Connection: "+str(conn_name) if conn_name not in self.conn_properties: self.logger.debug("DB Connection: new connection %s", conn_name) if self.config_file.has_section(section_name): self.logger.warning("DB Connection: a section with the name %s already \ exists although it is supposed to be a new connection, maybe a bug...", conn_name) else: self.config_file.add_section(section_name) self.conn_properties[conn_name] = {"plugin_type": props["plugin_type"]} if props != self.conn_properties[conn_name]: self.logger.debug("DB Connection: updated properties for %s", conn_name) if not self.config_file.has_section(section_name): self.config_file.add_section(section_name) for o, v in props.iteritems(): self.config_file.set(section_name, o, unicode(v)) self.conn_properties[conn_name] = props if conn_name in self.open_connections: conn = self.open_connections.pop(conn_name) conn.close(self.logger) get_notification_center().emitDBSettingChanged(conn_name) get_notification_center().emitRestartRequired("DB Settings were changed - you should restart") get_settings().set_available_db_connections(self.conn_properties.keys()) self.conn_plugins = {} self._init_plugin_objects() '''@todo release locks''' def discard_changes(self): self.conn_options_widget.reset_connection_properties(self.conn_properties)