* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
+#include "coresession.h"
+
#include <QtScript>
#include "core.h"
-#include "coresession.h"
#include "coreuserinputhandler.h"
-#include "signalproxy.h"
#include "corebuffersyncer.h"
#include "corebacklogmanager.h"
#include "corebufferviewmanager.h"
-#include "coreirclisthelper.h"
-#include "corenetworkconfig.h"
-#include "storage.h"
-
#include "coreidentity.h"
+#include "coreignorelistmanager.h"
+#include "coreirclisthelper.h"
#include "corenetwork.h"
-#include "ircuser.h"
-#include "ircchannel.h"
-
-#include "util.h"
+#include "corenetworkconfig.h"
+#include "coresessioneventprocessor.h"
#include "coreusersettings.h"
+#include "ctcpparser.h"
+#include "eventmanager.h"
+#include "eventstringifier.h"
+#include "ircchannel.h"
+#include "ircparser.h"
+#include "ircuser.h"
#include "logger.h"
-#include "coreignorelistmanager.h"
+#include "messageevent.h"
+#include "signalproxy.h"
+#include "storage.h"
+#include "util.h"
class ProcessMessagesEvent : public QEvent {
public:
_ircListHelper(new CoreIrcListHelper(this)),
_networkConfig(new CoreNetworkConfig("GlobalNetworkConfig", this)),
_coreInfo(this),
+ _eventManager(new EventManager(this)),
+ _eventStringifier(new EventStringifier(this)),
+ _sessionEventProcessor(new CoreSessionEventProcessor(this)),
+ _ctcpParser(new CtcpParser(this)),
+ _ircParser(new IrcParser(this)),
scriptEngine(new QScriptEngine(this)),
_processMessages(false),
_ignoreListManager(this)
{
SignalProxy *p = signalProxy();
+ p->setHeartBeatInterval(30);
+ p->setMaxHeartBeatCount(60); // 30 mins until we throw a dead socket out
+
connect(p, SIGNAL(peerRemoved(QIODevice *)), this, SLOT(removeClient(QIODevice *)));
connect(p, SIGNAL(connected()), this, SLOT(clientsConnected()));
loadSettings();
initScriptEngine();
+ eventManager()->registerObject(ircParser(), EventManager::NormalPriority);
+ eventManager()->registerObject(sessionEventProcessor(), EventManager::HighPriority); // needs to process events *before* the stringifier!
+ eventManager()->registerObject(ctcpParser(), EventManager::NormalPriority);
+ eventManager()->registerObject(eventStringifier(), EventManager::NormalPriority);
+ eventManager()->registerObject(this, EventManager::LowPriority); // for sending MessageEvents to the client
+ // some events need to be handled after msg generation
+ eventManager()->registerObject(sessionEventProcessor(), EventManager::LowPriority, "lateProcess");
+ eventManager()->registerObject(ctcpParser(), EventManager::LowPriority, "send");
+
// periodically save our session state
connect(&(Core::instance()->syncTimer()), SIGNAL(timeout()), this, SLOT(saveSessionState()));
QList<NetworkInfo>::iterator networkIter = networkInfos.begin();
while(networkIter != networkInfos.end()) {
if(networkIter->identity == id) {
- networkIter->identity = newId;
- Core::updateNetwork(user(), *networkIter);
- networkIter = networkInfos.erase(networkIter);
+ networkIter->identity = newId;
+ Core::updateNetwork(user(), *networkIter);
+ networkIter = networkInfos.erase(networkIter);
} else {
- networkIter++;
+ networkIter++;
}
}
s.removeIdentity(id);
_bufferSyncer->storeDirtyIds();
_bufferViewManager->saveBufferViews();
_networkConfig->save();
- _aliasManager.save();
- _ignoreListManager.save();
}
void CoreSession::restoreSessionState() {
// KDE's notifications), hence we remove those just to be safe.
QString text = text_;
text.remove(QChar(0xfdd0)).remove(QChar(0xfdd1));
+ RawMessage rawMsg(networkId, type, bufferType, target, text, sender, flags);
+
+ // check for HardStrictness ignore
+ CoreNetwork *currentNetwork = network(networkId);
+ QString networkName = currentNetwork ? currentNetwork->networkName() : QString("");
+ if(_ignoreListManager.match(rawMsg, networkName) == IgnoreListManager::HardStrictness)
+ return;
- _messageQueue << RawMessage(networkId, type, bufferType, target, text, sender, flags);
+ _messageQueue << rawMsg;
if(!_processMessages) {
_processMessages = true;
QCoreApplication::postEvent(this, new ProcessMessagesEvent());
emit displayStatusMsg(net->networkName(), msg);
}
+void CoreSession::processMessageEvent(MessageEvent *event) {
+ recvMessageFromServer(event->networkId(), event->msgType(), event->bufferType(),
+ event->target().isNull()? "" : event->target(),
+ event->text().isNull()? "" : event->text(),
+ event->sender().isNull()? "" : event->sender(),
+ event->msgFlags());
+}
+
QList<BufferInfo> CoreSession::buffers() const {
return Core::requestBuffers(user());
}
}
void CoreSession::processMessages() {
- QString networkName;
if(_messageQueue.count() == 1) {
const RawMessage &rawMsg = _messageQueue.first();
- BufferInfo bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target);
- Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
-
- CoreNetwork *currentNetwork = network(bufferInfo.networkId());
- networkName = currentNetwork ? currentNetwork->networkName() : QString("");
- // if message is ignored with "HardStrictness" we discard it here
- if(_ignoreListManager.match(msg, networkName) != IgnoreListManager::HardStrictness) {
- Core::storeMessage(msg);
- emit displayMsg(msg);
+ bool createBuffer = !(rawMsg.flags & Message::Redirected);
+ BufferInfo bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target, createBuffer);
+ if(!bufferInfo.isValid()) {
+ Q_ASSERT(!createBuffer);
+ bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
}
+ Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
+ Core::storeMessage(msg);
+ emit displayMsg(msg);
} else {
QHash<NetworkId, QHash<QString, BufferInfo> > bufferInfoCache;
MessageList messages;
+ QList<RawMessage> redirectedMessages; // list of Messages which don't enforce a buffer creation
BufferInfo bufferInfo;
for(int i = 0; i < _messageQueue.count(); i++) {
const RawMessage &rawMsg = _messageQueue.at(i);
if(bufferInfoCache.contains(rawMsg.networkId) && bufferInfoCache[rawMsg.networkId].contains(rawMsg.target)) {
- bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
+ bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
} else {
- bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target);
- bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
+ bool createBuffer = !(rawMsg.flags & Message::Redirected);
+ bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, rawMsg.bufferType, rawMsg.target, createBuffer);
+ if(!bufferInfo.isValid()) {
+ Q_ASSERT(!createBuffer);
+ redirectedMessages << rawMsg;
+ continue;
+ }
+ bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
}
+ Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
+ messages << msg;
+ }
+ // recheck if there exists a buffer to store a redirected message in
+ for(int i = 0; i < redirectedMessages.count(); i++) {
+ const RawMessage &rawMsg = _messageQueue.at(i);
+ if(bufferInfoCache.contains(rawMsg.networkId) && bufferInfoCache[rawMsg.networkId].contains(rawMsg.target)) {
+ bufferInfo = bufferInfoCache[rawMsg.networkId][rawMsg.target];
+ } else {
+ // no luck -> we store them in the StatusBuffer
+ bufferInfo = Core::bufferInfo(user(), rawMsg.networkId, BufferInfo::StatusBuffer, "");
+ // add the StatusBuffer to the Cache in case there are more Messages for the original target
+ bufferInfoCache[rawMsg.networkId][rawMsg.target] = bufferInfo;
+ }
Message msg(bufferInfo, rawMsg.type, rawMsg.text, rawMsg.sender, rawMsg.flags);
- CoreNetwork *currentNetwork = network(bufferInfo.networkId());
- networkName = currentNetwork ? currentNetwork->networkName() : QString("");
- // if message is ignored with "HardStrictness" we discard it here
- if(_ignoreListManager.match(msg, networkName) == IgnoreListManager::HardStrictness)
- continue;
messages << msg;
}
+
Core::storeMessages(messages);
// FIXME: extend protocol to a displayMessages(MessageList)
for(int i = 0; i < messages.count(); i++) {
QVariant CoreSession::sessionState() {
QVariantMap v;
+ v["CoreFeatures"] = (int)Quassel::features();
+
QVariantList bufs;
foreach(BufferInfo id, buffers()) bufs << qVariantFromValue(id);
v["BufferInfos"] = bufs;
connect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)),
SLOT(recvMessageFromServer(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)));
connect(net, SIGNAL(displayStatusMsg(QString)), SLOT(recvStatusMsgFromServer(QString)));
+ connect(net, SIGNAL(disconnected(NetworkId)), SIGNAL(networkDisconnected(NetworkId)));
net->setNetworkInfo(info);
net->setProxy(signalProxy());
return;
if(net->connectionState() != Network::Disconnected) {
+ // make sure we no longer receive data from the tcp buffer
+ disconnect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)), this, 0);
+ disconnect(net, SIGNAL(displayStatusMsg(QString)), this, 0);
connect(net, SIGNAL(disconnected(NetworkId)), this, SLOT(destroyNetwork(NetworkId)));
net->disconnectFromIrc();
} else {
QList<BufferId> removedBuffers = Core::requestBufferIdsForNetwork(user(), id);
Network *net = _networks.take(id);
if(net && Core::removeNetwork(user(), id)) {
+ // make sure that all unprocessed RawMessages from this network are removed
+ QList<RawMessage>::iterator messageIter = _messageQueue.begin();
+ while(messageIter != _messageQueue.end()) {
+ if(messageIter->networkId == id) {
+ messageIter = _messageQueue.erase(messageIter);
+ } else {
+ messageIter++;
+ }
+ }
+ // remove buffers from syncer
foreach(BufferId bufferId, removedBuffers) {
_bufferSyncer->removeBuffer(bufferId);
}
if(!net->isConnected())
continue;
+
identity = net->identityPtr();
if(!identity)
continue;
if(identity->detachAwayEnabled() && !me->isAway()) {
if(!identity->detachAwayReason().isEmpty())
- awayReason = identity->detachAwayReason();
+ awayReason = identity->detachAwayReason();
net->setAutoAwayActive(true);
net->userInputHandler()->handleAway(BufferInfo(), awayReason);
}
}
}
+
+
+void CoreSession::globalAway(const QString &msg) {
+ QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
+ CoreNetwork *net = 0;
+ while(netIter != _networks.end()) {
+ net = *netIter;
+ netIter++;
+
+ if(!net->isConnected())
+ continue;
+
+ net->userInputHandler()->issueAway(msg, false /* no force away */);
+ }
+}