p->synchronize(_coreInfo);
p->synchronize(&_ignoreListManager);
p->synchronize(&_highlightRuleManager);
+ // Listen to network removed events
+ connect(this, SIGNAL(networkRemoved(NetworkId)),
+ &_highlightRuleManager, SLOT(networkRemoved(NetworkId)));
p->synchronize(transferManager());
// Restore session state
if (restoreState)
}
-CoreSession::~CoreSession()
+void CoreSession::shutdown()
{
saveSessionState();
- /* Why partially duplicate CoreNetwork destructor? When each CoreNetwork quits in the
- * destructor, disconnections are processed in sequence for each object. For many IRC servers
- * on a slow network, this could significantly delay core shutdown [msecs wait * network count].
- *
- * Here, CoreSession first calls disconnect on all networks, letting them all start
- * disconnecting before beginning to sequentially wait for each network. Ideally, after the
- * first network is disconnected, the other networks will have already closed. Worst-case may
- * still wait [msecs wait time * num. of networks], but the risk should be much lower.
- *
- * CoreNetwork should still do cleanup in its own destructor in case a network is deleted
- * outside of deleting the whole CoreSession.
- *
- * If this proves to be problematic in the future, there's an alternative Qt signal-based system
- * implemented in another pull request that guarentees a maximum amount of time to disconnect,
- * but at the cost of more complex code.
- *
- * See https://github.com/quassel/quassel/pull/203
- */
-
- foreach(CoreNetwork *net, _networks.values()) {
- // Request each network properly disconnect, but don't count as user-requested disconnect
- if (net->socketConnected()) {
- // Only try if the socket's fully connected (not initializing or disconnecting).
- // Force an immediate disconnect, jumping the command queue. Ensures the proper QUIT is
- // shown even if other messages are queued.
- net->disconnectFromIrc(false, QString(), false, true);
+ // Request disconnect from all connected networks in parallel, and wait until every network
+ // has emitted the disconnected() signal before deleting the session itself
+ for (CoreNetwork *net : _networks.values()) {
+ if (net->socketState() != QAbstractSocket::UnconnectedState) {
+ _networksPendingDisconnect.insert(net->networkId());
+ connect(net, SIGNAL(disconnected(NetworkId)), this, SLOT(onNetworkDisconnected(NetworkId)));
+ net->shutdown();
}
}
- // Process the putCmd events that trigger the quit. Without this, shutting down the core
- // results in abrubtly closing the socket rather than sending the QUIT as expected.
- QCoreApplication::processEvents();
+ if (_networksPendingDisconnect.isEmpty()) {
+ // Nothing to do, suicide so the core can shut down
+ deleteLater();
+ }
+}
- foreach(CoreNetwork *net, _networks.values()) {
- // Wait briefly for each network to disconnect. Sometimes it takes a little while to send.
- if (!net->forceDisconnect()) {
- qWarning() << "Timed out quitting network" << net->networkName() <<
- "(user ID " << net->userId() << ")";
- }
- // Delete the network now that it's closed
- delete net;
+
+void CoreSession::onNetworkDisconnected(NetworkId networkId)
+{
+ _networksPendingDisconnect.remove(networkId);
+ if (_networksPendingDisconnect.isEmpty()) {
+ // We're done, suicide so the core can shut down
+ deleteLater();
}
}
CoreNetwork *CoreSession::network(NetworkId id) const
{
if (_networks.contains(id)) return _networks[id];
- return 0;
+ return nullptr;
}
CoreIdentity *CoreSession::identity(IdentityId id) const
{
if (_identities.contains(id)) return _identities[id];
- return 0;
+ return nullptr;
}
void CoreSession::restoreSessionState()
{
QList<NetworkId> nets = Core::connectedNetworks(user());
- CoreNetwork *net = 0;
+ CoreNetwork *net = nullptr;
foreach(NetworkId id, nets) {
net = network(id);
Q_ASSERT(net);
if (_ignoreListManager.match(rawMsg, networkName) == IgnoreListManager::HardStrictness)
return;
- if (_highlightRuleManager.match(rawMsg, currentNetwork->myNick(), currentNetwork->identityPtr()->nicks()))
+
+ if (currentNetwork && _highlightRuleManager.match(rawMsg, currentNetwork->myNick(), currentNetwork->identityPtr()->nicks()))
rawMsg.flags |= Message::Flag::Highlight;
_messageQueue << rawMsg;
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);
+ disconnect(net, SIGNAL(displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &, const QString &, const QString &, Message::Flags)), this, nullptr);
+ disconnect(net, SIGNAL(displayStatusMsg(QString)), this, nullptr);
connect(net, SIGNAL(disconnected(NetworkId)), this, SLOT(destroyNetwork(NetworkId)));
net->disconnectFromIrc();
}
void CoreSession::clientsConnected()
{
QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
- Identity *identity = 0;
- CoreNetwork *net = 0;
- IrcUser *me = 0;
+ Identity *identity = nullptr;
+ CoreNetwork *net = nullptr;
+ IrcUser *me = nullptr;
while (netIter != _networks.end()) {
net = *netIter;
++netIter;
void CoreSession::clientsDisconnected()
{
QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
- Identity *identity = 0;
- CoreNetwork *net = 0;
- IrcUser *me = 0;
+ Identity *identity = nullptr;
+ CoreNetwork *net = nullptr;
+ IrcUser *me = nullptr;
QString awayReason;
while (netIter != _networks.end()) {
net = *netIter;
void CoreSession::globalAway(const QString &msg, const bool skipFormatting)
{
QHash<NetworkId, CoreNetwork *>::iterator netIter = _networks.begin();
- CoreNetwork *net = 0;
+ CoreNetwork *net = nullptr;
while (netIter != _networks.end()) {
net = *netIter;
++netIter;