def deactivate(self):
try:
get_notification_center().disconnectPeerAppended(self.peer_update)
get_notification_center().disconnectPeerUpdated(self.peer_update)
except:
self.logger.warning("Problem while disconnecting signals", exc_info=1)
iface_called_plugin.deactivate(self)
def newSetter(self, action, category, *args, **kwargs):
pluginName = action.getPluginName()
actionName = action.getName()
if "applyImmediately" in kwargs:
applyImmediately = kwargs["applyImmediately"]
del kwargs["applyImmediately"]
else:
applyImmediately = True
if "categoryPolicy" in kwargs:
categoryPolicy = kwargs["categoryPolicy"]
del kwargs["categoryPolicy"]
else:
categoryPolicy = False
if applyImmediately:
# check if modification is in progress
settings = self._getActionDict(pluginName, actionName, self._modifications)
if settings is not None:
# apply to modified
if categoryPolicy is not self.CATEGORY_NEVER:
settings = self._initModification(action, category, actionDictSource=self._modifications)
func(self, action, category, settingsDict=settings, *args, **kwargs)
# apply to stored settings
settings = self._initModification(action, category, actionDictSource=self._settings, categoryPolicy=categoryPolicy)
func(self, action, category, settingsDict=settings, *args, **kwargs)
get_notification_center().emitPrivacySettingsChanged(action.getPluginName(), action.getName())
else:
# only add to modification dict
settings = self._initModification(action, category, actionDictSource=self._modifications, categoryPolicy=categoryPolicy)
func(self, action, category, settingsDict=settings, *args, **kwargs)
def create_widget(self, parent):
from PyQt4.QtGui import QSortFilterProxyModel
from PyQt4.QtCore import Qt, QTimer
from lunchinator.table_widget import TableWidget
from messages_table.messages_table_model import MessagesTableModel
self.messagesTable = TableWidget(
parent, "Send Message", self.sendMessageClicked, placeholderText="Enter a message", sortingEnabled=False
)
# initialize messages table
self.messagesModel = MessagesTableModel(parent)
self.messagesTable.setModel(self.messagesModel)
self.messagesTable.setColumnWidth(0, 120)
self.messagesTable.setColumnWidth(1, 90)
get_notification_center().connectMessagePrepended(self.messagesModel.messagePrepended)
get_notification_center().connectDisplayedPeerNameChanged(self.messagesModel.updateSenders)
self._dailyTrigger = QTimer(parent)
self._dailyTrigger.timeout.connect(self._updateTimes)
self._dailyTrigger.setSingleShot(True)
self._updateDailyTrigger()
return self.messagesTable
def addGroup(self, group_name):
"""adds a new group
(done by the lunch server thread)"""
if group_name not in self._groups:
self._groups.add(group_name)
# TODO: what was the second parameter supposed to be?
get_notification_center().emitGroupAppended(group_name, self._groups)
def _addMember(self, pID):
if pID not in self._memberIDs:
self.logger.debug("Peer %s is a member", pID)
self._memberIDs.add(pID)
get_notification_center().emitMemberAppended(pID, deepcopy(self.getPeerInfo(pID=pID, lock=False)))
else: # something may have changed for the member data
get_notification_center().emitMemberUpdated(pID, deepcopy(self.getPeerInfo(pID=pID, lock=False)))
def checkForUpdates(self, forced=False):
"""Checks each repository for updates.
Returns a set of paths where updates are available.
forced -- If True, repositories with autoUpdate==False are checked, too.
"""
with self._lock:
# make a copy s.t. we don't have to lock the repos all the time
repos = deepcopy(self._externalRepos)
outdated = set()
upToDate = set()
gh = GitHandler(getCoreLogger())
for path, _active, autoUpdate in repos:
if forced or autoUpdate:
if gh.needsPull(path=path):
outdated.add(path)
else:
upToDate.add(path)
with self._lock:
self._outdated -= upToDate
self._outdated.update(outdated)
self._upToDate -= outdated
self._upToDate.update(upToDate)
if outdated:
get_notification_center().emitOutdatedRepositoriesChanged()
if upToDate:
get_notification_center().emitUpToDateRepositoriesChanged()
return outdated
def testMemberRemovalLock(self):
get_notification_center().connectMemberRemoved(self.connect_testMemberRemovalLock)
print "Removing myself as Member"
mIPs = get_peers().getPeerIPs(get_settings().get_ID())
print "Using IPs:", mIPs
get_peers().removeMembersByIP(mIPs)
def _installReady(self):
"""Makes the install button enabled/disabled"""
self._install_ready = True
get_notification_center().emitApplicationUpdate()
displayNotification("New Version Available", "Install via Update Plugin", self.logger)
if self._ui != None:
self._ui.appInstallReady()
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 discard(self, notify=True):
"""Discards all modifications since the last save"""
with self._lock:
for pluginName, pluginDict in self._modifications.iteritems():
for actionName, _actionDict in pluginDict.iteritems():
if notify:
get_notification_center().emitPrivacySettingsDiscarded(pluginName, actionName)
self._modifications = {}
def closeEvent(self, event):
if not self.getChatWidget().canClose():
event.ignore()
else:
self.windowClosing.emit(self._otherID)
get_notification_center().disconnectDisplayedPeerNameChanged(self._displayedPeerNameChanged)
self.getChatWidget().finish()
event.accept()
def set_group(self, value, init=False):
from lunchinator import get_server
oldGroup = self._group
self._group = value
if not init:
getCoreLogger().info("Changing Group: '%s' -> '%s'", oldGroup, self._group)
get_server().changeGroup(unicode(value))
get_notification_center().emitGroupChanged(oldGroup, self._group)
def processMessage(self, xmsg, addr, eventTime, newPeer, fromQueue):
""" process any message event, including lunch calls
@type xmsg: extMessageIncoming
@type addr: unicode
@type eventTime: float
@type newPeer: bool
@type fromQueue: bool
"""
mtime = localtime(eventTime)
t = strftime("%a, %d %b %Y %H:%M:%S", mtime).decode("utf-8")
msg = xmsg.getPlainMessage()
if not newPeer:
with get_peers():
m = get_peers().getPeerInfo(pIP=addr, lock=False)
peerName = get_peers().getDisplayedPeerName(pIP=addr, lock=False)
if m is None:
getCoreLogger().error("Error processing message: info dict is None")
else:
if peerName is None:
peerName = m.get(LunchPeers.PEER_NAME_KEY, "<unknown>")
getCoreLogger().info("%s: [%s (%s)] %s", t, peerName, m[LunchPeers.PEER_ID_KEY], msg)
self._insertMessage(mtime, m[LunchPeers.PEER_ID_KEY], msg)
get_notification_center().emitMessagePrepended(mtime, m[LunchPeers.PEER_ID_KEY], msg)
else:
m = {u"ID": addr}
processLunchCall = False
#deprecated:
self.processPluginCall(addr, lambda p, ip, member_info: p.process_message(msg, ip, member_info), newPeer, fromQueue)
#the next block could be one huge statement, but for readability I leave it as is
if get_settings().get_lunch_trigger() in msg.lower():
# the message contains the lunch keyword
if eventTime - self.last_lunch_call > get_settings().get_mute_timeout() or \
fromQueue and self.last_lunch_call == eventTime:
# it has not been reported before
# the call has not been during the mute_timeout or
# this is a queued lunch call that previously wasn't muted
diff = getTimeDifference(get_settings().get_alarm_begin_time(), get_settings().get_alarm_end_time(), getCoreLogger())
if diff == None or 0 < diff:
# either the time format is invalid or we are within the alarm time
processLunchCall = True
else:
diff = getTimeDifference(get_settings().get_next_lunch_begin(), get_settings().get_next_lunch_end(), getCoreLogger())
if diff == None or 0 < diff:
# either the time format is invalid or we are within the free for lunch time
processLunchCall = True
if processLunchCall:
self.last_lunch_call = eventTime
#deprecated:
self.processPluginCall(addr, lambda p, ip, member_info: p.process_lunch_call(msg, ip, member_info), newPeer, fromQueue)
else:
getCoreLogger().debug("messages will not trigger alarm: %s: [%s] %s until %s (unless you change the setting, that is)", t, m, msg, strftime("%H:%M:%S", localtime(eventTime + get_settings().get_mute_timeout())))
self.processPluginCall(addr, lambda p, ip, member_info: p.process_group_message(xmsg, ip, member_info, processLunchCall), newPeer, fromQueue)
def setGlobalLevel(cls, newLevel):
if newLevel == cls._globalLevel:
return
cls._globalLevel = newLevel
for name, logger in cls._loggers.iteritems():
if name not in cls._specificLevels:
logger.setLevel(newLevel)
from lunchinator import get_notification_center
get_notification_center().emitLoggingLevelChanged(None, newLevel)
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 deactivate(self):
"""
Just call the parent class's method
"""
if len(self._supported_dbms)>0:
get_notification_center().disconnectDBSettingChanged(self.connect_to_db)
self.option_widgets = {}
removeLogger(self.plugin_name)
IPlugin.deactivate(self)
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 __init__(self, parent):
super(ErrorLogDialog, self).__init__(parent, Qt.WindowStaysOnTopHint)
self._empty = True
self._initUI()
self.setWindowTitle("Error")
get_notification_center().connectLogMessage(self._checkLogMessage)
for record in getCachedLogRecords():
self._checkLogMessage(record)
def __init__(self, parent, logger, ownName, otherName, ownPicFile, otherPicFile, otherID, sendAction):
super(ChatWindow, self).__init__(parent)
self.logger = logger
self._otherID = otherID
self._chatWidget = ChatWidget(self, logger, ownName, otherName, ownPicFile, otherPicFile, otherID, sendAction)
self.setCentralWidget(self._chatWidget)
self.setWindowTitle(otherName)
self.setWindowIcon(QIcon(get_settings().get_resource("images", "lunchinator_chat.png")))
get_notification_center().connectDisplayedPeerNameChanged(self._displayedPeerNameChanged)
def removePeer(self, pID):
with self._lock:
if pID not in self._idToIp:
return
pIPs = self._idToIp.pop(pID)
self._removeMember(pID)
for pIP in pIPs:
self._peer_info.pop(pIP)
get_notification_center().emitPeerRemoved(pID)
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 finish(self):
get_notification_center().disconnectPeerAppended(self._peerUpdated)
get_notification_center().disconnectPeerUpdated(self._peerUpdated)
get_notification_center().disconnectPeerRemoved(self._peerRemoved)
get_notification_center().disconnectAvatarChanged(self._avatarChanged)
get_notification_center().disconnectDisplayedPeerNameChanged(self._displayedPeerNameChanged)
if self._typingTimer is not None:
self._typingTimer.stop()
self._typingTimer.deleteLater()
self._typingTimer = None
def __init__(self, parent):
super(listPluginsWidget, self).__init__(parent)
self.ui = Ui_Plugins()
self.ui.setupUi(self)
self.p_info = self.get_plugin_info()
self.create_plugin_view(False)
self.ui.pluginView.setCurrentRow(0)
get_notification_center().connectPluginActivated(self.update_plugin_view)
get_notification_center().connectPluginDeactivated(self.update_plugin_view)
def setCustomName(self, peerID, customName, infoDict=None):
"""Called from lunch_peers, no locking"""
self._checkCache(peerID)
peerName, oldCustomName = self._peerNameCache[peerID]
if peerName == None:
self.logger.error("Trying to specify custom name for unknown peer")
return
self._peerNameCache[peerID] = (peerName, customName)
if oldCustomName != customName:
self._db.execute("UPDATE CORE_PEER_NAMES SET CUSTOM_NAME = ? WHERE PEER_ID = ?", customName, peerID)
get_notification_center().emitDisplayedPeerNameChanged(peerID, self.getDisplayedPeerName(peerID), infoDict)
def __init__(self, parent, logger):
super(ConsoleWidget, self).__init__(parent)
self.logger = logger
self._errorColor = QVariant(QColor(180, 0, 0))
self._warningColor = QVariant(QColor(170, 100, 0))
self._records = []
self._initModel()
self._initUI()
get_notification_center().connectLogMessage(self._addLogMessage)
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 destroy_widget(self):
if self._dailyTrigger != None:
self._dailyTrigger.timeout.disconnect(self._updateTimes)
self._dailyTrigger.stop()
self._dailyTrigger.deleteLater()
get_notification_center().disconnectMessagePrepended(self.messagesModel.messagePrepended)
get_notification_center().disconnectDisplayedPeerNameChanged(self.messagesModel.updateSenders)
self.messagesModel = None
self.messagesTable = None
iface_gui_plugin.destroy_widget(self)
def _addPeerIPtoID(self, pID, ip):
if pID not in self._idToIp:
self._idToIp[pID] = [ip]
if self._peerNames is not None:
self._peerNames.addPeerName(pID, self._peer_info[ip])
get_notification_center().emitPeerAppended(pID, deepcopy(self._peer_info[ip]))
else:
# last one is last seen one
self._idToIp[pID].append(ip)
# workaround to get the IP over to the slots
cp = deepcopy(self._peer_info[ip])
cp["triggerIP"] = ip
get_notification_center().emitPeerUpdated(pID, cp)
def activate(self):
"""
Call the parent class's activation method
"""
IPlugin.activate(self)
self.logger = newLogger(self.plugin_name)
self._initOptions()
self._readOptionsFromFile()
if len(self._supported_dbms)>0:
get_notification_center().connectDBSettingChanged(self.connect_to_db)
self.connect_to_db()
return
def _removePeerIPfromID(self, pID, ip):
self.logger.debug("Removing %s from ID: %s", ip, pID)
self._idToIp[pID].remove(ip)
if 0 == len(self._idToIp[pID]):
# no IP associated with that ID -> remove peer
# remove member first
self._removeMember(pID)
self._idToIp.pop(pID)
get_notification_center().emitPeerRemoved(pID)
else:
existing_ip = self._idToIp[pID][0]
get_notification_center().emitPeerUpdated(pID, deepcopy(self._peer_info[existing_ip]))
