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")
