def serverStopped(self, _exit_code): get_settings().write_config_to_hd() if get_settings().get_plugins_enabled(): get_plugin_manager().deactivatePlugins(get_plugin_manager().getAllPlugins(), save_state=False) get_notification_center().disconnectPluginActivated(self._checkSendInfoDict) get_notification_center().disconnectPluginDeactivated(self._checkSendInfoDict) get_notification_center().finish() DataReceiverThread.cleanup()
def toggle_plugin(self, p_name, p_cat, new_state): try: p_cat = convert_string(p_cat) p_name = convert_string(p_name) if new_state: get_plugin_manager().activatePluginByName(p_name, p_cat) else: get_plugin_manager().deactivatePluginByName(p_name, p_cat) except: getCoreLogger().exception("Error toggling plugin")
def activate_plugin_toggled(self, item): p_name = str(item.toolTip()) if item.checkState()==Qt.Checked and not self.p_info[p_name]["activated"]: get_plugin_manager().activatePluginByName(\ self.p_info[p_name]["full_name"], self.p_info[p_name]["categories"][0]) self.p_info[p_name]["activated"]=True elif item.checkState()==Qt.Unchecked and self.p_info[p_name]["activated"]: pluginInfo = get_plugin_manager().getPluginByName(self.p_info[p_name]["full_name"], self.p_info[p_name]["categories"][0]) get_plugin_manager().deactivatePlugins([pluginInfo]) self.p_info[p_name]["activated"]=False
def getPluginNames(self, listActivated, listDeactivated, category = None): try: plugins = None if get_settings().get_plugins_enabled(): if category == None: plugins = get_plugin_manager().getAllPlugins() else: plugins = get_plugin_manager().getPluginsOfCategory(category) for pluginInfo in plugins: if pluginInfo.plugin_object.is_activated and listActivated or\ not pluginInfo.plugin_object.is_activated and listDeactivated: yield (pluginInfo.name, pluginInfo.description, pluginInfo.categories) except: getCoreLogger().exception("while collecting option categories")
def __init__(self): cmd.Cmd.__init__(self) LunchServerController.__init__(self) self.logger = newLogger("cli") self.prompt = "> " self.commands = set(["exit"]) self.addModule(CLIMessageHandling()) self.addModule(CLIOptionHandling()) self.addModule(CLIPluginHandling(self)) self.addModule(CLIPrivacyHandling()) self.addModule(CLILoggingHandling()) get_server().initialize(self) if get_settings().get_plugins_enabled(): for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.plugin_object.is_activated: self.addModule(pluginInfo.plugin_object) get_notification_center().connectApplicationUpdate(self.notifyUpdates) self.exitCode = 0 # if serverStopped is called, we can determine if it was a regular exit. self.cleanExit = False self.initialized = False
def getPluginObject(self, cat): cat = cat.upper() if get_settings().get_plugins_enabled(): for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.plugin_object.is_activated and pluginInfo.name.upper() == cat: return pluginInfo.plugin_object return None
def _checkSendInfoDict(self, pluginName, category): pluginName = convert_string(pluginName) category = convert_string(category) pi = get_plugin_manager().getPluginByName(pluginName, category) if pi != None: po = pi.plugin_object if po.extendsInfoDict(): get_server().call_info()
def loadPlugins(self, args): while len(args) > 0: pluginName = args.pop(0).upper() try: pInfo = None for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.name.upper() == pluginName: pInfo = pluginInfo if pInfo == None: print "Unknown plugin. The available plugins are:" self.listPlugins(args) elif pInfo.plugin_object.is_activated: print "Plugin already loaded." else: get_plugin_manager().activatePlugin(pluginInfo=pInfo) self.parent.addModule(pInfo.plugin_object) except: getCoreLogger().exception("while loading plugin")
def _pluginDeactivated(self, pluginName, category): pluginName = convert_string(pluginName) category = convert_string(category) pi = get_plugin_manager().getPluginByName(pluginName, category) if pi: with self._lock: removed = self._removeActionsForPlugin(pi) if removed: get_notification_center().emitPeerActionsRemoved(removed)
def _pluginActivated(self, pluginName, category): pluginName = convert_string(pluginName) category = convert_string(category) pi = get_plugin_manager().getPluginByName(pluginName, category) if pi: with self._lock: added = self._addActionsForPlugin(pi) if added: get_notification_center().emitPeerActionsAdded(added)
def initialize(self): """Called from lunch server controller""" with self._lock: self._peerActions[self.STANDARD_PEER_ACTIONS_KEY] = getStandardPeerActions() self._addMessagePrefixes(self._peerActions[self.STANDARD_PEER_ACTIONS_KEY]) for pi in get_plugin_manager().getAllPlugins(): if pi.plugin_object.is_activated: self._addActionsForPlugin(pi)
def getOptionCategories(self): try: if get_settings().get_plugins_enabled(): for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.plugin_object.is_activated: if pluginInfo.plugin_object.has_options(): yield (pluginInfo.name, pluginInfo.description) except: getCoreLogger().exception("while collecting option categories")
def _pluginActivated(self, pName, pCat): pName = convert_string(pName) pCat = convert_string(pCat) if pCat == "gui": try: pluginInfo = get_plugin_manager().getPluginByName(pName, u"gui") self.addPluginWidget(pluginInfo.plugin_object, pName) except: getCoreLogger().exception("while including plugins %s", str(sys.exc_info()))
def _pluginWillBeDeactivated(self, pName, pCat): pName = convert_string(pName) pCat = convert_string(pCat) if pCat == "gui": pluginInfo = get_plugin_manager().getPluginByName(pName, pCat) try: pluginInfo.plugin_object.destroy_widget() except: getCoreLogger().exception("Error destroying plugin widget for plugin %s", pName) self.removePluginWidget(pName)
def quit(self, exitCode=0): if self.mainWindow is not None: self.mainWindow.close() if self.settingsWindow is not None: self.settingsWindow.close() if self.serverThread != None and not sip.isdeleted(self.serverThread) and self.serverThread.isRunning(): self.serverThread.finished.disconnect(self.serverFinishedUnexpectedly) get_server().stop_server() getCoreLogger().info("Waiting maximal 30s for server to stop...") # wait maximal 30s if self.serverThread.wait(30000): getCoreLogger().info("server stopped") else: getCoreLogger().warning("server not stopped properly") else: getCoreLogger().info("server not running") if self.running: if get_settings().get_plugins_enabled(): get_plugin_manager().deactivatePlugins(get_plugin_manager().getAllPlugins(), save_state=False) getCoreLogger().info("all plug-ins deactivated") if self.mainWindow is not None: self.mainWindow.finish() if self.settingsWindow is not None: self.settingsWindow.finish() self.running = False finalExitCode = 0 if exitCode != 0: finalExitCode = exitCode elif self.exitCode != 0: finalExitCode = self.exitCode else: finalExitCode = get_server().exitCode get_settings().write_config_to_hd() DataReceiverThread.cleanup() self.exitCode = finalExitCode self._coldShutdown(finalExitCode) return finalExitCode
def extendMemberInfo(self, infoDict): """Add some specific information to the info dictionary""" if not get_settings().get_plugins_enabled(): return for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.plugin_object.is_activated and pluginInfo.plugin_object.extendsInfoDict(): try: pluginInfo.plugin_object.extendInfoDict(infoDict) except: getCoreLogger().exception(u"plugin error in %s while extending member info" % pluginInfo.name)
def unloadPlugins(self, args): pluginInfos = [] while len(args) > 0: pluginName = args.pop(0).upper() try: pInfo = None for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.name.upper() == pluginName: pInfo = pluginInfo if pInfo == None: print "Unknown plugin. The available plugins are:" self.listPlugins(args) elif not pInfo.plugin_object.is_activated: print "Plugin is not loaded." else: pluginInfos.append(pInfo) self.parent.removeModule(pInfo.plugin_object) except: getCoreLogger().exception("while unloading plugin") get_plugin_manager().deactivatePlugins(pluginInfos)
def __init__(self, controller): super(LunchinatorWindow, self).__init__(None) self.guiHandler = controller self.setWindowTitle("Lunchinator") self.setWindowIcon(QIcon(get_settings().get_resource("images", "lunchinator.png"))) self.setDockNestingEnabled(True) self.setTabPosition(Qt.AllDockWidgetAreas, QTabWidget.North) self.pluginNameToDockWidget = {} self.objectNameToPluginName = {} self.pluginNameToMenus = {} self.settings = QSettings(get_settings().get_config("gui_settings.ini"), QSettings.IniFormat) savedGeometry = self.settings.value("geometry", None) savedState = self.settings.value("state", None) self.locked = self.settings.value("locked", QVariant(False)).toBool() self._prepareMenuBar() if savedState == None: # first run, create initial state get_plugin_manager().activatePluginByName(u"Simple View", "gui") get_plugin_manager().activatePluginByName(u"Auto Update", "general") # add plugins try: if get_settings().get_plugins_enabled(): for pluginInfo in get_plugin_manager().getPluginsOfCategory("gui"): if pluginInfo.plugin_object.is_activated: self.addPluginWidget(pluginInfo.plugin_object, pluginInfo.name, noTabs=True) except: getCoreLogger().exception("while including plugins %s", str(sys.exc_info())) if savedGeometry != None: self.restoreGeometry(savedGeometry.toByteArray()) else: self.centerOnScreen() if savedState != None: self.restoreState(savedState.toByteArray()) get_notification_center().connectPluginActivated(self._pluginActivated) get_notification_center().connectPluginWillBeDeactivated(self._pluginWillBeDeactivated) if len(self.pluginNameToDockWidget) == 0 and get_settings().get_plugins_enabled(): # no gui plugins activated, show about plugins get_plugin_manager().activatePluginByName(u"About Plugins", "gui") if self.locked: self.lockDockWidgets() # prevent from closing twice self.closed = False
def __init__(self, parent): super(LunchinatorSettingsDialog, self).__init__(parent, Qt.Dialog) self.setWindowTitle("Lunchinator Settings") # self.setModal(True) self.setResult(QDialog.Rejected) contentLayout = QVBoxLayout(self) self.nb = ComboTabWidget(self) self.nb.setTabPosition(QTabWidget.North) self.widget_containers = {} self.widget_names = [] try: if get_settings().get_plugins_enabled(): for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.plugin_object.is_activated: self.addPlugin(pluginInfo.plugin_object, pluginInfo.name, pluginInfo.category) except: getCoreLogger().exception("while including plugins in settings window") contentLayout.addWidget(self.nb) # d.get_content_area().pack_start(nb, True, True, 0) if self.nb.count() > 0: self.nb.setCurrentIndex(0) # show first widget self.nb.widget(0).showContents() buttonBox = QDialogButtonBox(Qt.Horizontal, self) saveButton = QPushButton("Save", self) # saveButton.setAutoDefault(True) saveButton.clicked.connect(self.savePressed) buttonBox.addButton(saveButton, QDialogButtonBox.AcceptRole) cancelButton = QPushButton("Cancel", self) cancelButton.clicked.connect(self.cancelPressed) buttonBox.addButton(cancelButton, QDialogButtonBox.RejectRole) applyButton = QPushButton("Apply", self) applyButton.clicked.connect(self.applyPressed) buttonBox.addButton(applyButton, QDialogButtonBox.ApplyRole) discardButton = QPushButton("Discard", self) discardButton.clicked.connect(self.discardPressed) buttonBox.addButton(discardButton, QDialogButtonBox.ApplyRole) contentLayout.addWidget(buttonBox) get_notification_center().connectPluginActivated(self._pluginActivated) get_notification_center().connectPluginWillBeDeactivated(self._pluginWillBeDeactivated)
def processPluginCall(self, ip, call, newPeer, fromQueue, action=None): """ call plugins @type ip: unicode @type call: function @type newPeer: bool @type fromQueue: bool @type action: PeerAction """ if not get_settings().get_plugins_enabled(): return member_info = get_peers().getPeerInfo(pIP=ip) # called also contains gui plugins for pluginInfo in get_plugin_manager().getPluginsOfCategory("called")+get_plugin_manager().getPluginsOfCategory("gui"): # if this is a peer action, only call special plugins if action is None or (pluginInfo.plugin_object.processes_all_peer_actions() and \ pluginInfo.name != action.getPluginName()): self._processCallOnPlugin(pluginInfo.plugin_object, pluginInfo.name, ip, call, newPeer, fromQueue, member_info) # perform peer action if action is not None: self._processCallOnPlugin(action.getPluginObject(), action.getPluginName(), ip, call, newPeer, fromQueue, member_info)
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
def settingsDialogAction(self, saved): if not get_settings().get_plugins_enabled(): return for pluginInfo in get_plugin_manager().getAllPlugins(): if pluginInfo.plugin_object.is_activated and self.settingsWindow.isOptionsWidgetLoaded(pluginInfo.name): if saved: try: pluginInfo.plugin_object.save_options_widget_data(sendInfoDict=False) except: getCoreLogger().exception("was not able to save data for plugin %s", pluginInfo.name) else: pluginInfo.plugin_object.discard_changes() get_settings().write_config_to_hd() get_server().call_info()
def __init__(self, parent, conn_properties): super(DbConnOptions, self).__init__(parent) self.plugin_manager = get_plugin_manager() self.available_types = {} self.conn_properties = None for dbplugin in self.plugin_manager.getPluginsOfCategory("db"): self.available_types[dbplugin.name] = dbplugin.plugin_object lay = QGridLayout(self) if len(self.available_types) == 0: lay.addWidget(QLabel("No DB plugin activated", parent), 0, 0, Qt.AlignRight) return lay.addWidget(QLabel("Name: ", parent), 0, 0, Qt.AlignRight) self.nameCombo = QComboBox(parent) lay.addWidget(self.nameCombo, 0, 1) lay.addWidget(QLabel("Type: ", parent), 1, 0, Qt.AlignRight) self.typeCombo = QComboBox(parent) lay.addWidget(self.typeCombo, 1, 1) self.conn_details = QStackedWidget(parent) lay.addWidget(self.conn_details, 2, 0, 1, 2) newConnButton = QPushButton("New Connection", parent) lay.addWidget(newConnButton, 3, 1) self.warningLbl = QLabel("The standard connection is used by the lunchinator internally to store messages etc." + \ " It can be used by plugins as well, but it cannot be changed.") self.warningLbl.setWordWrap(True) lay.addWidget(self.warningLbl, 4, 0, 4, 2) for p in self.available_types.values(): w = p.create_db_options_widget(parent) if w == None: w = QLabel("Plugin not activated", parent) self.conn_details.addWidget(w) self.typeCombo.addItems(self.available_types.keys()) self.reset_connection_properties(conn_properties) newConnButton.clicked.connect(self.new_conn)
def get_plugin_info(self): info = {} for pluginInfo in get_plugin_manager().getAllPlugins(): short_name = pluginInfo.plugin_object.get_displayed_name() p = {} p["name"] = pluginInfo.name if not short_name else short_name p["full_name"] = pluginInfo.name p["categories"] = pluginInfo.categories p["author"] = pluginInfo.author # txt+=pluginInfo.path +" " # txt+=pluginInfo.version +" " # txt+=pluginInfo.copyright +" " # txt+=pluginInfo.website +" " p["description"] = pluginInfo.description p["requirements"] = [] if pluginInfo.details.has_option("Requirements", "pip"): p["requirements"] = [req.strip() for req in pluginInfo.details.get("Requirements", "pip").split(";;")] p["forced"] = pluginInfo.plugin_object.force_activation p["activated"] = pluginInfo.plugin_object.is_activated info[pluginInfo.name] = p return info
def init_menu(self, parent): # create the plugin submenu menu = QMenu(parent) plugin_menu = QMenu("PlugIns", menu) self.pluginActions = None if get_settings().get_plugins_enabled(): allPlugins = [x for x in get_plugin_manager().getAllPlugins() if not x.plugin_object.is_activation_forced()] if get_settings().get_group_plugins(): self.pluginActions = {} catMenus = {} for pluginInfo in sorted(allPlugins, key=lambda info : self._getDisplayedName(info)): categoryMenu = None anAction = None for aCat in pluginInfo.categories: if aCat in catMenus: categoryMenu = catMenus[aCat] else: categoryMenu = QMenu(aCat, plugin_menu) catMenus[aCat] = categoryMenu if anAction == None: anAction = self._create_plugin_action(pluginInfo, categoryMenu, aCat) else: categoryMenu.addAction(anAction) if aCat in self.pluginActions: self.pluginActions[aCat].append(anAction) else: self.pluginActions[aCat] = [anAction] for _cat, aMenu in sorted(catMenus.iteritems(), key=lambda aTuple : aTuple[0]): plugin_menu.addMenu(aMenu) else: self.pluginActions = [] for pluginInfo in sorted(allPlugins, key=lambda info : self._getDisplayedName(info)): anAction = self._create_plugin_action(pluginInfo, plugin_menu, pluginInfo.categories[0]) self.pluginActions.append(anAction) # main _menu self._memberStatusAction = menu.addAction("Initializing...") self._memberStatusAction.setEnabled(False) if hasattr(menu, "addSeparator"): menu.addSeparator() get_notification_center().connectMemberAppended(self._updateMemberStatus) get_notification_center().connectMemberUpdated(self._updateMemberStatus) get_notification_center().connectMemberRemoved(self._updateMemberStatus) self.memberStatusUpdateTimer = QTimer(self) self.memberStatusUpdateTimer.timeout.connect(self._startSyncedTimer) self.memberStatusUpdateTimer.start(msecUntilNextMinute()) anAction = menu.addAction('Call for lunch') anAction.triggered.connect(partial(self.sendMessageClicked, u'lunch')) anAction = menu.addAction('Show Lunchinator') anAction.triggered.connect(self.openWindowClicked) anAction = menu.addAction(u"Change today's lunch time") anAction.triggered.connect(self.changeNextLunchTime) if hasattr(menu, "addSeparator"): menu.addSeparator() anAction = menu.addAction('Settings') anAction.triggered.connect(self.openSettingsClicked) menu.addMenu(plugin_menu) if hasattr(menu, "addSeparator"): menu.addSeparator() self._restartStatusAction = menu.addAction(self._restartReason) self._restartStatusAction.setEnabled(False) self._restartAction = menu.addAction("Restart") self._restartAction.triggered.connect(partial(restart, getCoreLogger())) if self._restartReason: self._restartStatusAction.setVisible(True) self._restartAction.setVisible(True) else: self._restartStatusAction.setVisible(False) self._restartAction.setVisible(False) self._appUpdateStatusAction = menu.addAction("Lunchinator can be updated") self._appUpdateStatusAction.setEnabled(False) self._appUpdateStatusAction.setVisible(self._updateAvailable) self._repoUpdateStatusAction = menu.addAction("") self._repoUpdateStatusAction.setEnabled(False) self._updateRepoUpdateStatusAction() self._installUpdatesAction = menu.addAction("Install updates and restart") self._installUpdatesAction.triggered.connect(get_notification_center().emitInstallUpdates) self._installUpdatesAction.setVisible(self._updateAvailable) anAction = menu.addAction('Exit') anAction.triggered.connect(self.quitClicked) return menu
def completeList(self, _args, _argNum, _text): return (aCat for aCat in get_plugin_manager().getCategories() if aCat.startswith(_text))
def _pluginWillBeDeactivated(self, pName, pCat): pName = convert_string(pName) pCat = convert_string(pCat) pluginInfo = get_plugin_manager().getPluginByName(pName, pCat) if pluginInfo is not None: self.removePlugin(pluginInfo.plugin_object, pName, pCat)
def _dockWidgetClosed(self, pluginName): get_plugin_manager().deactivatePluginByName(pluginName, "gui")