X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fcoresession.cpp;h=020950f6de73ee110f10f1ba6ed4da3d65023848;hp=112f60c2bab554987f8bafc26d307453002e5551;hb=0d49f7e83bd1055711e66aa880f3a0d62f7eefc9;hpb=6623fd2d46dadd0168e4e28d1db6944c26c2a773 diff --git a/src/core/coresession.cpp b/src/core/coresession.cpp index 112f60c2..020950f6 100644 --- a/src/core/coresession.cpp +++ b/src/core/coresession.cpp @@ -18,61 +18,88 @@ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ +#include + #include "core.h" #include "coresession.h" #include "networkconnection.h" +#include "userinputhandler.h" #include "signalproxy.h" +#include "buffersyncer.h" +#include "corebacklogmanager.h" +#include "corebufferviewmanager.h" +#include "coreirclisthelper.h" #include "storage.h" -#include "network.h" +#include "corenetwork.h" #include "ircuser.h" #include "ircchannel.h" #include "identity.h" #include "util.h" #include "coreusersettings.h" +#include "logger.h" -#include - -CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent) : QObject(parent), +CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent) + : QObject(parent), _user(uid), _signalProxy(new SignalProxy(SignalProxy::Server, 0, this)), + _aliasManager(this), + _bufferSyncer(new BufferSyncer(this)), + _backlogManager(new CoreBacklogManager(this)), + _bufferViewManager(new CoreBufferViewManager(_signalProxy, this)), + _ircListHelper(new CoreIrcListHelper(this)), + _coreInfo(this), scriptEngine(new QScriptEngine(this)) { SignalProxy *p = signalProxy(); + connect(p, SIGNAL(peerRemoved(QIODevice *)), this, SLOT(removeClient(QIODevice *))); - CoreUserSettings s(user()); - sessionData = s.sessionData(); - - p->attachSlot(SIGNAL(requestConnect(QString)), this, SLOT(connectToNetwork(QString))); - p->attachSlot(SIGNAL(disconnectFromNetwork(NetworkId)), this, SLOT(disconnectFromNetwork(NetworkId))); // FIXME + //p->attachSlot(SIGNAL(disconnectFromNetwork(NetworkId)), this, SLOT(disconnectFromNetwork(NetworkId))); // FIXME p->attachSlot(SIGNAL(sendInput(BufferInfo, QString)), this, SLOT(msgFromClient(BufferInfo, QString))); - p->attachSlot(SIGNAL(requestBacklog(BufferInfo, QVariant, QVariant)), this, SLOT(sendBacklog(BufferInfo, QVariant, QVariant))); p->attachSignal(this, SIGNAL(displayMsg(Message))); p->attachSignal(this, SIGNAL(displayStatusMsg(QString, QString))); - p->attachSignal(this, SIGNAL(backlogData(BufferInfo, QVariantList, bool))); p->attachSignal(this, SIGNAL(bufferInfoUpdated(BufferInfo))); - p->attachSignal(this, SIGNAL(sessionDataChanged(const QString &, const QVariant &)), SIGNAL(coreSessionDataChanged(const QString &, const QVariant &))); - p->attachSlot(SIGNAL(clientSessionDataChanged(const QString &, const QVariant &)), this, SLOT(storeSessionData(const QString &, const QVariant &))); - p->attachSignal(this, SIGNAL(identityCreated(const Identity &))); p->attachSignal(this, SIGNAL(identityRemoved(IdentityId))); p->attachSlot(SIGNAL(createIdentity(const Identity &)), this, SLOT(createIdentity(const Identity &))); - p->attachSlot(SIGNAL(updateIdentity(const Identity &)), this, SLOT(updateIdentity(const Identity &))); p->attachSlot(SIGNAL(removeIdentity(IdentityId)), this, SLOT(removeIdentity(IdentityId))); p->attachSignal(this, SIGNAL(networkCreated(NetworkId))); p->attachSignal(this, SIGNAL(networkRemoved(NetworkId))); p->attachSlot(SIGNAL(createNetwork(const NetworkInfo &)), this, SLOT(createNetwork(const NetworkInfo &))); - p->attachSlot(SIGNAL(updateNetwork(const NetworkInfo &)), this, SLOT(updateNetwork(const NetworkInfo &))); p->attachSlot(SIGNAL(removeNetwork(NetworkId)), this, SLOT(removeNetwork(NetworkId))); loadSettings(); initScriptEngine(); + // init BufferSyncer + QHash lastSeenHash = Core::bufferLastSeenMsgIds(user()); + foreach(BufferId id, lastSeenHash.keys()) + _bufferSyncer->requestSetLastSeenMsg(id, lastSeenHash[id]); + + connect(_bufferSyncer, SIGNAL(lastSeenMsgSet(BufferId, MsgId)), this, SLOT(storeBufferLastSeenMsg(BufferId, MsgId))); + connect(_bufferSyncer, SIGNAL(removeBufferRequested(BufferId)), this, SLOT(removeBufferRequested(BufferId))); + connect(this, SIGNAL(bufferRemoved(BufferId)), _bufferSyncer, SLOT(removeBuffer(BufferId))); + connect(this, SIGNAL(bufferRenamed(BufferId, QString)), _bufferSyncer, SLOT(renameBuffer(BufferId, QString))); + p->synchronize(_bufferSyncer); + + + // init alias manager + p->synchronize(&aliasManager()); + + // init BacklogManager + p->synchronize(_backlogManager); + + // init IrcListHelper + p->synchronize(ircListHelper()); + + // init CoreInfo + p->synchronize(&_coreInfo); + // Restore session state if(restoreState) restoreSessionState(); @@ -82,10 +109,10 @@ CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent) : QObje CoreSession::~CoreSession() { saveSessionState(); foreach(NetworkConnection *conn, _connections.values()) { - conn->deleteLater(); + delete conn; } - foreach(Network *net, _networks.values()) { - net->deleteLater(); + foreach(CoreNetwork *net, _networks.values()) { + delete net; } } @@ -93,7 +120,7 @@ UserId CoreSession::user() const { return _user; } -Network *CoreSession::network(NetworkId id) const { +CoreNetwork *CoreSession::network(NetworkId id) const { if(_networks.contains(id)) return _networks[id]; return 0; } @@ -114,16 +141,17 @@ void CoreSession::loadSettings() { foreach(IdentityId id, s.identityIds()) { Identity *i = new Identity(s.identity(id), this); if(!i->isValid()) { - qWarning() << QString("Invalid identity! Removing..."); + quWarning() << "Invalid identity! Removing..."; s.removeIdentity(id); delete i; continue; } if(_identities.contains(i->id())) { - qWarning() << "Duplicate identity, ignoring!"; + quWarning() << "Duplicate identity, ignoring!"; delete i; continue; } + connect(i, SIGNAL(updated(const QVariantMap &)), this, SLOT(identityUpdated(const QVariantMap &))); _identities[i->id()] = i; signalProxy()->synchronize(i); } @@ -134,113 +162,36 @@ void CoreSession::loadSettings() { createIdentity(i); } - foreach(NetworkId id, s.networkIds()) { - NetworkInfo info = s.networkInfo(id); - createNetwork(info, true); - } - - // FIXME Migrate old settings if available... - if(!_networks.count()) { - QVariantMap networks = retrieveSessionData("Networks").toMap(); - if(networks.keys().count()) { - qWarning() << "Migrating your old network settings to the new format!"; - foreach(QString netname, networks.keys()) { - QVariantMap network = networks[netname].toMap(); - NetworkId netid = Core::networkId(user(), netname); - NetworkInfo info; - info.networkId = netid; - info.networkName = netname; - info.identity = 1; - info.codecForEncoding = "ISO-8859-15"; - info.codecForDecoding = "ISO-8859-15"; - QVariantList slist; - foreach(QVariant v, network["Servers"].toList()) { - QVariantMap server; - server["Host"] = v.toMap()["Address"]; - server["Port"] = v.toMap()["Port"]; - slist << server; - } - info.serverList = slist; - createNetwork(info, true); - } - } + foreach(NetworkInfo info, Core::networks(user())) { + createNetwork(info); } } void CoreSession::saveSessionState() const { - QVariantMap res; - QVariantList conn; - foreach(NetworkConnection *net, _connections.values()) { - QVariantMap m; - m["NetworkId"] = QVariant::fromValue(net->networkId()); - m["State"] = net->state(); - conn << m; - } - res["CoreBuild"] = Global::quasselBuild; - res["ConnectedNetworks"] = conn; - CoreUserSettings s(user()); - s.setSessionState(res); + } void CoreSession::restoreSessionState() { - CoreUserSettings s(user()); - uint build = s.sessionState().toMap()["CoreBuild"].toUInt(); - if(build < 362) { - qWarning() << qPrintable(tr("Session state does not exist or is too old!")); - return; + QList nets = Core::connectedNetworks(user()); + foreach(NetworkId id, nets) { + connectToNetwork(id); } - QVariantList conn = s.sessionState().toMap()["ConnectedNetworks"].toList(); - foreach(QVariant v, conn) { - NetworkId id = v.toMap()["NetworkId"].value(); - if(_networks.keys().contains(id)) connectToNetwork(id, v.toMap()["State"]); - } -} - - -void CoreSession::storeSessionData(const QString &key, const QVariant &data) { - CoreUserSettings s(user()); - s.setSessionValue(key, data); - sessionData[key] = data; - emit sessionDataChanged(key, data); - emit sessionDataChanged(key); -} - -QVariant CoreSession::retrieveSessionData(const QString &key, const QVariant &def) { - QVariant data; - if(!sessionData.contains(key)) data = def; - else data = sessionData[key]; - return data; } void CoreSession::updateBufferInfo(UserId uid, const BufferInfo &bufinfo) { if(uid == user()) emit bufferInfoUpdated(bufinfo); } -// FIXME remove -void CoreSession::connectToNetwork(QString netname, const QVariant &previousState) { - Network *net = 0; - foreach(Network *n, _networks.values()) { - if(n->networkName() == netname) { - net = n; break; - } - } - if(!net) { - qWarning() << "Connect to unknown network requested, ignoring!"; - return; - } - connectToNetwork(net->networkId(), previousState); -} - -void CoreSession::connectToNetwork(NetworkId id, const QVariant &previousState) { - Network *net = network(id); +void CoreSession::connectToNetwork(NetworkId id) { + CoreNetwork *net = network(id); if(!net) { - qWarning() << "Connect to unknown network requested! net:" << id << "user:" << user(); + quWarning() << "Connect to unknown network requested! net:" << id << "user:" << user(); return; } NetworkConnection *conn = networkConnection(id); if(!conn) { - conn = new NetworkConnection(net, this, previousState); + conn = new NetworkConnection(net, this); _connections[id] = conn; attachNetworkConnection(conn); } @@ -249,30 +200,42 @@ void CoreSession::connectToNetwork(NetworkId id, const QVariant &previousState) void CoreSession::attachNetworkConnection(NetworkConnection *conn) { connect(conn, SIGNAL(connected(NetworkId)), this, SLOT(networkConnected(NetworkId))); - connect(conn, SIGNAL(disconnected(NetworkId)), this, SLOT(networkDisconnected(NetworkId))); + connect(conn, SIGNAL(quitRequested(NetworkId)), this, SLOT(networkDisconnected(NetworkId))); // I guess we don't need these anymore, client-side can just connect the network's signals directly //signalProxy()->attachSignal(conn, SIGNAL(connected(NetworkId)), SIGNAL(networkConnected(NetworkId))); //signalProxy()->attachSignal(conn, SIGNAL(disconnected(NetworkId)), SIGNAL(networkDisconnected(NetworkId))); - connect(conn, SIGNAL(displayMsg(Message::Type, QString, QString, QString, quint8)), this, SLOT(recvMessageFromServer(Message::Type, QString, QString, QString, quint8))); + connect(conn, SIGNAL(displayMsg(Message::Type, BufferInfo::Type, QString, QString, QString, Message::Flags)), + this, SLOT(recvMessageFromServer(Message::Type, BufferInfo::Type, QString, QString, QString, Message::Flags))); connect(conn, SIGNAL(displayStatusMsg(QString)), this, SLOT(recvStatusMsgFromServer(QString))); + connect(conn, SIGNAL(nickChanged(const NetworkId &, const QString &, const QString &)), + this, SLOT(renameBuffer(const NetworkId &, const QString &, const QString &))); + connect(conn, SIGNAL(channelJoined(NetworkId, const QString &, const QString &)), + this, SLOT(channelJoined(NetworkId, const QString &, const QString &))); + connect(conn, SIGNAL(channelParted(NetworkId, const QString &)), + this, SLOT(channelParted(NetworkId, const QString &))); } void CoreSession::disconnectFromNetwork(NetworkId id) { - if(!_connections.contains(id)) return; - _connections[id]->disconnectFromIrc(); + if(!_connections.contains(id)) + return; + + //_connections[id]->disconnectFromIrc(); + _connections[id]->userInputHandler()->handleQuit(BufferInfo(), QString()); } void CoreSession::networkStateRequested() { } -void CoreSession::addClient(QObject *dev) { // this is QObject* so we can use it in signal connections - QIODevice *device = qobject_cast(dev); +void CoreSession::addClient(QIODevice *device) { if(!device) { - qWarning() << "Invoking CoreSession::addClient with a QObject that is not a QIODevice!"; + quError() << "Invoking CoreSession::addClient with a QObject that is not a QIODevice!"; } else { + // if the socket is an orphan, the signalProxy adopts it. + // -> we don't need to care about it anymore + device->setParent(0); signalProxy()->addPeer(device); QVariantMap reply; reply["MsgType"] = "SessionInit"; @@ -281,45 +244,70 @@ void CoreSession::addClient(QObject *dev) { // this is QObject* so we can use it } } +void CoreSession::addClient(SignalProxy *proxy) { + signalProxy()->addPeer(proxy); + emit sessionState(sessionState()); +} + +void CoreSession::removeClient(QIODevice *iodev) { + QTcpSocket *socket = qobject_cast(iodev); + if(socket) + quInfo() << qPrintable(tr("Client")) << qPrintable(socket->peerAddress().toString()) << qPrintable(tr("disconnected (UserId: %1).").arg(user().toInt())); +} + SignalProxy *CoreSession::signalProxy() const { return _signalProxy; } // FIXME we need a sane way for creating buffers! void CoreSession::networkConnected(NetworkId networkid) { - Core::bufferInfo(user(), networkConnection(networkid)->networkName()); // create status buffer + Core::bufferInfo(user(), networkid, BufferInfo::StatusBuffer); // create status buffer + Core::setNetworkConnected(user(), networkid, true); } +// called now only on /quit and requested disconnects, not on normal disconnects! void CoreSession::networkDisconnected(NetworkId networkid) { - // FIXME - // connection should only go away on explicit /part, and handle reconnections etcpp internally otherwise + // if the network has already been removed, we don't have a networkconnection left either, so we don't do anything + // make sure to not depend on the network still existing when calling this function! + if(_connections.contains(networkid)) { + Core::setNetworkConnected(user(), networkid, false); + _connections.take(networkid)->deleteLater(); + } +} - Q_ASSERT(_connections.contains(networkid)); - _connections.take(networkid)->deleteLater(); +void CoreSession::channelJoined(NetworkId id, const QString &channel, const QString &key) { + Core::setChannelPersistent(user(), id, channel, true); + Core::setPersistentChannelKey(user(), id, channel, key); +} + +void CoreSession::channelParted(NetworkId id, const QString &channel) { + Core::setChannelPersistent(user(), id, channel, false); +} + +QHash CoreSession::persistentChannels(NetworkId id) const { + return Core::persistentChannels(user(), id); + return QHash(); } // FIXME switch to BufferId void CoreSession::msgFromClient(BufferInfo bufinfo, QString msg) { NetworkConnection *conn = networkConnection(bufinfo.networkId()); if(conn) { - conn->userInput(bufinfo.buffer(), msg); + conn->userInput(bufinfo, msg); } else { - qWarning() << "Trying to send to unconnected network!"; + quWarning() << "Trying to send to unconnected network:" << msg; } } // ALL messages coming pass through these functions before going to the GUI. // So this is the perfect place for storing the backlog and log stuff. -void CoreSession::recvMessageFromServer(Message::Type type, QString target, QString text, QString sender, quint8 flags) { - NetworkConnection *s = qobject_cast(this->sender()); - Q_ASSERT(s); - BufferInfo buf; - if((flags & Message::PrivMsg) && !(flags & Message::Self)) { - buf = Core::bufferInfo(user(), s->networkName(), nickFromMask(sender)); - } else { - buf = Core::bufferInfo(user(), s->networkName(), target); - } - Message msg(buf, type, text, sender, flags); +void CoreSession::recvMessageFromServer(Message::Type type, BufferInfo::Type bufferType, + QString target, QString text, QString sender, Message::Flags flags) { + NetworkConnection *netCon = qobject_cast(this->sender()); + Q_ASSERT(netCon); + + BufferInfo bufferInfo = Core::bufferInfo(user(), netCon->networkId(), bufferType, target); + Message msg(bufferInfo, type, text, sender, flags); msg.setMsgId(Core::storeMessage(msg)); Q_ASSERT(msg.msgId() != 0); emit displayMsg(msg); @@ -359,34 +347,14 @@ QVariant CoreSession::sessionState() { foreach(Identity *i, _identities.values()) idlist << qVariantFromValue(*i); v["Identities"] = idlist; - v["SessionData"] = sessionData; - - //v["Payload"] = QByteArray(100000000, 'a'); // for testing purposes + //v["Payload"] = QByteArray(100000000, 'a'); // for testing purposes return v; } -void CoreSession::sendBacklog(BufferInfo id, QVariant v1, QVariant v2) { - QList log; - QList msglist; - if(v1.type() == QVariant::DateTime) { - - - } else { - msglist = Core::requestMsgs(id, v1.toInt(), v2.toInt()); - } - - // Send messages out in smaller packages - we don't want to make the signal data too large! - for(int i = 0; i < msglist.count(); i++) { - log.append(qVariantFromValue(msglist[i])); - if(log.count() >= 5) { - emit backlogData(id, log, i >= msglist.count() - 1); - log.clear(); - } - } - if(log.count() > 0) emit backlogData(id, log, true); +void CoreSession::storeBufferLastSeenMsg(BufferId buffer, const MsgId &msgId) { + Core::setBufferLastSeenMsg(user(), buffer, msgId); } - void CoreSession::initScriptEngine() { signalProxy()->attachSlot(SIGNAL(scriptRequest(QString)), this, SLOT(scriptRequest(QString))); signalProxy()->attachSignal(this, SIGNAL(scriptResult(QString))); @@ -415,20 +383,10 @@ void CoreSession::createIdentity(const Identity &id) { signalProxy()->synchronize(newId); CoreUserSettings s(user()); s.storeIdentity(*newId); + connect(newId, SIGNAL(updated(const QVariantMap &)), this, SLOT(identityUpdated(const QVariantMap &))); emit identityCreated(*newId); } -void CoreSession::updateIdentity(const Identity &id) { - if(!_identities.contains(id.id())) { - qWarning() << "Update request for unknown identity received!"; - return; - } - _identities[id.id()]->update(id); - - CoreUserSettings s(user()); - s.storeIdentity(id); -} - void CoreSession::removeIdentity(IdentityId id) { Identity *i = _identities.take(id); if(i) { @@ -439,47 +397,109 @@ void CoreSession::removeIdentity(IdentityId id) { } } -/*** Network Handling ***/ - -void CoreSession::createNetwork(const NetworkInfo &_info, bool useId) { - NetworkInfo info = _info; - int id; - if(useId && info.networkId > 0) id = info.networkId.toInt(); - else { - for(id = 1; id <= _networks.count(); id++) { - if(!_networks.keys().contains(id)) break; - } - //qDebug() << "found free id" << i; - info.networkId = id; +void CoreSession::identityUpdated(const QVariantMap &data) { + IdentityId id = data.value("identityId", 0).value(); + if(!id.isValid() || !_identities.contains(id)) { + quWarning() << "Update request for unknown identity received!"; + return; } - Network *net = new Network(id, this); - connect(net, SIGNAL(connectRequested(NetworkId)), this, SLOT(connectToNetwork(NetworkId))); - connect(net, SIGNAL(disconnectRequested(NetworkId)), this, SLOT(disconnectFromNetwork(NetworkId))); - net->setNetworkInfo(info); - net->setProxy(signalProxy()); - _networks[id] = net; - signalProxy()->synchronize(net); CoreUserSettings s(user()); - s.storeNetworkInfo(info); - emit networkCreated(id); + s.storeIdentity(*_identities.value(id)); } -void CoreSession::updateNetwork(const NetworkInfo &info) { - if(!_networks.contains(info.networkId)) { - qWarning() << "Update request for unknown network received!"; +/*** Network Handling ***/ + +void CoreSession::createNetwork(const NetworkInfo &info_) { + NetworkInfo info = info_; + int id; + + if(!info.networkId.isValid()) + Core::createNetwork(user(), info); + + if(!info.networkId.isValid()) { + quWarning() << qPrintable(tr("CoreSession::createNetwork(): Got invalid networkId from Core when trying to create network %1!").arg(info.networkName)); return; } - _networks[info.networkId]->setNetworkInfo(info); - CoreUserSettings s(user()); - s.storeNetworkInfo(info); + + id = info.networkId.toInt(); + if(!_networks.contains(id)) { + CoreNetwork *net = new CoreNetwork(id, this); + connect(net, SIGNAL(connectRequested(NetworkId)), this, SLOT(connectToNetwork(NetworkId))); + connect(net, SIGNAL(disconnectRequested(NetworkId)), this, SLOT(disconnectFromNetwork(NetworkId))); + net->setNetworkInfo(info); + net->setProxy(signalProxy()); + _networks[id] = net; + signalProxy()->synchronize(net); + emit networkCreated(id); + } else { + quWarning() << qPrintable(tr("CoreSession::createNetwork(): Trying to create a network that already exists, updating instead!")); + _networks[info.networkId]->requestSetNetworkInfo(info); + } } void CoreSession::removeNetwork(NetworkId id) { + // Make sure the network is disconnected! + NetworkConnection *conn = _connections.value(id, 0); + if(conn) { + if(conn->connectionState() != Network::Disconnected) { + connect(conn, SIGNAL(disconnected(NetworkId)), this, SLOT(destroyNetwork(NetworkId))); + conn->disconnectFromIrc(); + } else { + _connections.take(id)->deleteLater(); // TODO make this saner + destroyNetwork(id); + } + } else { + destroyNetwork(id); + } +} + +void CoreSession::destroyNetwork(NetworkId id) { + if(_connections.contains(id)) { + // this can happen if the network was reconnecting while being removed + _connections.take(id)->deleteLater(); + } + QList removedBuffers = Core::requestBufferIdsForNetwork(user(), id); Network *net = _networks.take(id); - if(net) { + if(net && Core::removeNetwork(user(), id)) { + foreach(BufferId bufferId, removedBuffers) { + _bufferSyncer->removeBuffer(bufferId); + } emit networkRemoved(id); - CoreUserSettings s(user()); - s.removeNetworkInfo(id); net->deleteLater(); } } + +void CoreSession::removeBufferRequested(BufferId bufferId) { + BufferInfo bufferInfo = Core::getBufferInfo(user(), bufferId); + if(!bufferInfo.isValid()) { + quWarning() << "CoreSession::removeBufferRequested(): invalid BufferId:" << bufferId << "for User:" << user(); + return; + } + + if(bufferInfo.type() == BufferInfo::StatusBuffer) { + quWarning() << "CoreSession::removeBufferRequested(): Status Buffers cannot be removed!"; + return; + } + + if(bufferInfo.type() == BufferInfo::ChannelBuffer) { + CoreNetwork *net = network(bufferInfo.networkId()); + if(!net) { + quWarning() << "CoreSession::removeBufferRequested(): Received BufferInfo with unknown networkId!"; + return; + } + IrcChannel *chan = net->ircChannel(bufferInfo.bufferName()); + if(chan) { + quWarning() << "CoreSession::removeBufferRequested(): Unable to remove Buffer for joined Channel:" << bufferInfo.bufferName(); + return; + } + } + if(Core::removeBuffer(user(), bufferId)) + emit bufferRemoved(bufferId); +} + +void CoreSession::renameBuffer(const NetworkId &networkId, const QString &newName, const QString &oldName) { + BufferId bufferId = Core::renameBuffer(user(), networkId, newName, oldName); + if(bufferId.isValid()) { + emit bufferRenamed(bufferId, newName); + } +}