noury/mirror-chatterino2
1
0
Fork 0
mirror of https://github.com/Chatterino/chatterino2.git synced 2024-11-13 19:49:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

added code to handle a single connection

Browse source
This commit is contained in:
fourtf 2018-07-16 17:23:41 +02:00
parent e51c5c692a
commit 3b3c5d8d75
18 changed files with 114 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/Application.hpp
View file

@ -46,8 +46,8 @@ public:
friend void test();
[[deprecated("use getSettings() instead")]] Settings *settings = nullptr;
[[deprecated("use getPaths() instead")]] Paths *paths = nullptr;
Settings *settings = nullptr;
Paths *paths = nullptr;
Theme *themes = nullptr;
WindowManager *windows = nullptr;

11
src/common/NetworkData.cpp
View file

@ -2,12 +2,23 @@
#include "Application.hpp"
#include "singletons/Paths.hpp"
#include "util/DebugCount.hpp"
#include <QCryptographicHash>
#include <QFile>
namespace chatterino {
NetworkData::NetworkData()
{
DebugCount::increase("NetworkData");
}
NetworkData::~NetworkData()
{
DebugCount::decrease("NetworkData");
}
QString NetworkData::getHash()
{
if (this->hash_.isEmpty()) {

3
src/common/NetworkData.hpp
View file

@ -13,6 +13,9 @@ namespace chatterino {
class NetworkResult;
struct NetworkData {
NetworkData();
~NetworkData();
QNetworkRequest request_;
const QObject *caller_ = nullptr;
bool useQuickLoadCache_{};

32
src/common/NetworkRequest.cpp
View file

@ -167,20 +167,21 @@ void NetworkRequest::doRequest()
this->timer->start();
auto onUrlRequested = [data = this->data, timer = this->timer, worker]() mutable {
QNetworkReply *reply = nullptr;
switch (data->requestType_) {
case NetworkRequestType::Get: {
reply = NetworkManager::NaM.get(data->request_);
} break;
auto reply = [&]() -> QNetworkReply * {
switch (data->requestType_) {
case NetworkRequestType::Get:
return NetworkManager::NaM.get(data->request_);
case NetworkRequestType::Put: {
reply = NetworkManager::NaM.put(data->request_, data->payload_);
} break;
case NetworkRequestType::Put:
return NetworkManager::NaM.put(data->request_, data->payload_);
case NetworkRequestType::Delete: {
reply = NetworkManager::NaM.deleteResource(data->request_);
} break;
}
case NetworkRequestType::Delete:
return NetworkManager::NaM.deleteResource(data->request_);
default:
return nullptr;
}
}();
if (reply == nullptr) {
Log("Unhandled request type");
@ -201,8 +202,6 @@ void NetworkRequest::doRequest()
data->onReplyCreated_(reply);
}
bool directAction = (data->caller_ == nullptr);
auto handleReply = [data, timer, reply]() mutable {
// TODO(pajlada): A reply was received, kill the timeout timer
if (reply->error() != QNetworkReply::NetworkError::NoError) {
@ -222,8 +221,7 @@ void NetworkRequest::doRequest()
};
if (data->caller_ != nullptr) {
QObject::connect(worker, &NetworkWorker::doneUrl, data->caller_,
std::move(handleReply));
QObject::connect(worker, &NetworkWorker::doneUrl, data->caller_, handleReply);
QObject::connect(reply, &QNetworkReply::finished, worker, [worker]() mutable {
emit worker->doneUrl();
@ -231,7 +229,7 @@ void NetworkRequest::doRequest()
});
} else {
QObject::connect(reply, &QNetworkReply::finished, worker,
[handleReply = std::move(handleReply), worker]() mutable {
[handleReply, worker]() mutable {
handleReply();
delete worker;

2
src/controllers/commands/CommandController.cpp
View file

@ -140,7 +140,7 @@ QString CommandController::execCommand(const QString &text, ChannelPtr channel,
app->twitch.server->whispersChannel->addMessage(b.getMessage());
app->twitch.server->getWriteConnection()->sendRaw("PRIVMSG #jtv :" + text + "\r\n");
app->twitch.server->sendMessage("jtv", text);
if (getSettings()->inlineWhispers) {
app->twitch.server->forEachChannel(

38
src/providers/irc/AbstractIrcServer.cpp
View file

@ -35,26 +35,18 @@ AbstractIrcServer::AbstractIrcServer()
// this->writeConnection->reconnectRequested.connect([this] { this->connect(); });
}
IrcConnection *AbstractIrcServer::getReadConnection() const
{
return this->readConnection_.get();
}
IrcConnection *AbstractIrcServer::getWriteConnection() const
{
return this->writeConnection_.get();
}
void AbstractIrcServer::connect()
{
this->disconnect();
// if (this->hasSeparateWriteConnection()) {
this->initializeConnection(this->writeConnection_.get(), false, true);
this->initializeConnection(this->readConnection_.get(), true, false);
// } else {
// this->initializeConnection(this->readConnection.get(), true, true);
// }
bool separateWriteConnection = this->hasSeparateWriteConnection();
if (separateWriteConnection) {
this->initializeConnection(this->writeConnection_.get(), false, true);
this->initializeConnection(this->readConnection_.get(), true, false);
} else {
this->initializeConnection(this->readConnection_.get(), true, true);
}
// fourtf: this should be asynchronous
{
@ -67,7 +59,6 @@ void AbstractIrcServer::connect()
continue;
}
this->writeConnection_->sendRaw("JOIN #" + chan->name);
this->readConnection_->sendRaw("JOIN #" + chan->name);
}
@ -88,13 +79,18 @@ void AbstractIrcServer::disconnect()
}
void AbstractIrcServer::sendMessage(const QString &channelName, const QString &message)
{
this->sendRawMessage("PRIVMSG #" + channelName + " :" + message);
}
void AbstractIrcServer::sendRawMessage(const QString &rawMessage)
{
std::lock_guard<std::mutex> locker(this->connectionMutex_);
// fourtf: trim the message if it's sent from twitch chat
if (this->writeConnection_) {
this->writeConnection_->sendRaw("PRIVMSG #" + channelName + " :" + message);
if (this->hasSeparateWriteConnection()) {
this->writeConnection_->sendRaw(rawMessage);
} else {
this->readConnection_->sendRaw(rawMessage);
}
}

5
src/providers/irc/AbstractIrcServer.hpp
View file

@ -17,13 +17,11 @@ public:
virtual ~AbstractIrcServer() = default;
// connection
IrcConnection *getReadConnection() const;
IrcConnection *getWriteConnection() const;
void connect();
void disconnect();
void sendMessage(const QString &channelName, const QString &message);
void sendRawMessage(const QString &rawMessage);
// channels
std::shared_ptr<Channel> getOrAddChannel(const QString &dirtyChannelName);
@ -54,6 +52,7 @@ protected:
virtual std::shared_ptr<Channel> getCustomChannel(const QString &channelName);
virtual bool hasSeparateWriteConnection() const = 0;
virtual QString cleanChannelName(const QString &dirtyChannelName);
QMap<QString, std::weak_ptr<Channel>> channels;

17
src/providers/irc/IrcConnection2.cpp
View file

@ -9,18 +9,23 @@ IrcConnection::IrcConnection(QObject *parent)
this->pingTimer_.setInterval(5000);
this->pingTimer_.start();
QObject::connect(&this->pingTimer_, &QTimer::timeout, [this] {
if (!this->recentlyReceivedMessage_.load()) {
this->sendRaw("PING");
this->reconnectTimer_.start();
if (this->isConnected()) {
if (!this->recentlyReceivedMessage_.load()) {
this->sendRaw("PING");
this->reconnectTimer_.start();
}
this->recentlyReceivedMessage_ = false;
}
this->recentlyReceivedMessage_ = false;
});
// reconnect after x seconds without receiving a message
this->reconnectTimer_.setInterval(5000);
this->reconnectTimer_.setSingleShot(true);
QObject::connect(&this->reconnectTimer_, &QTimer::timeout,
[this] { reconnectRequested.invoke(); });
QObject::connect(&this->reconnectTimer_, &QTimer::timeout, [this] {
if (this->isConnected()) {
reconnectRequested.invoke();
}
});
QObject::connect(this, &Communi::IrcConnection::messageReceived, [this](Communi::IrcMessage *) {
this->recentlyReceivedMessage_ = true;

7
src/providers/twitch/TwitchChannel.cpp
View file

@ -19,7 +19,7 @@
namespace chatterino {
TwitchChannel::TwitchChannel(const QString &channelName, Communi::IrcConnection *readConnection)
TwitchChannel::TwitchChannel(const QString &channelName)
: Channel(channelName, Channel::Type::Twitch)
, bttvEmotes_(new EmoteMap)
, ffzEmotes_(new EmoteMap)
@ -27,7 +27,6 @@ TwitchChannel::TwitchChannel(const QString &channelName, Communi::IrcConnection
, channelUrl_("https://twitch.tv/" + name)
, popoutPlayerUrl_("https://player.twitch.tv/?channel=" + name)
, mod_(false)
, readConnection_(readConnection)
{
Log("[TwitchChannel:{}] Opened", this->name);
@ -420,7 +419,9 @@ bool TwitchChannel::parseRecentMessages(const QJsonObject &jsonRoot)
for (const auto jsonMessage : jsonMessages) {
auto content = jsonMessage.toString().toUtf8();
auto message = Communi::IrcMessage::fromData(content, this->readConnection_);
// passing nullptr as the channel makes the message invalid but we don't check for that
// anyways
auto message = Communi::IrcMessage::fromData(content, nullptr);
auto privMsg = dynamic_cast<Communi::IrcPrivateMessage *>(message);
assert(privMsg);

3
src/providers/twitch/TwitchChannel.hpp
View file

@ -86,7 +86,7 @@ private:
QString localizedName;
};
explicit TwitchChannel(const QString &channelName, Communi::IrcConnection *readConnection);
explicit TwitchChannel(const QString &channelName);
// Methods
void refreshLiveStatus();
@ -124,7 +124,6 @@ private:
QObject lifetimeGuard_;
QTimer liveStatusTimer_;
QTimer chattersListTimer_;
Communi::IrcConnection *readConnection_ = nullptr;
friend class TwitchServer;
};

19
src/providers/twitch/TwitchServer.cpp
View file

@ -28,6 +28,9 @@ TwitchServer::TwitchServer()
qDebug() << "init TwitchServer";
this->pubsub = new PubSub;
getSettings()->twitchSeperateWriteConnection.connect([this](auto, auto) { this->connect(); },
this->signalHolder_, false);
}
void TwitchServer::initialize(Application &app)
@ -42,12 +45,13 @@ void TwitchServer::initializeConnection(IrcConnection *connection, bool isRead,
{
assert(this->app);
this->singleConnection_ = isRead == isWrite;
std::shared_ptr<TwitchAccount> account = getApp()->accounts->twitch.getCurrent();
qDebug() << "logging in as" << account->getUserName();
QString username = account->getUserName();
// QString oauthClient = account->getOAuthClient();
QString oauthToken = account->getOAuthToken();
if (!oauthToken.startsWith("oauth:")) {
@ -60,9 +64,6 @@ void TwitchServer::initializeConnection(IrcConnection *connection, bool isRead,
if (!account->isAnon()) {
connection->setPassword(oauthToken);
// fourtf: ignored users
// this->refreshIgnoredUsers(username, oauthClient, oauthToken);
}
connection->sendCommand(Communi::IrcCommand::createCapability("REQ", "twitch.tv/membership"));
@ -75,7 +76,7 @@ void TwitchServer::initializeConnection(IrcConnection *connection, bool isRead,
std::shared_ptr<Channel> TwitchServer::createChannel(const QString &channelName)
{
TwitchChannel *channel = new TwitchChannel(channelName, this->getReadConnection());
TwitchChannel *channel = new TwitchChannel(channelName);
channel->sendMessageSignal.connect([this, channel](auto &chan, auto &msg, bool &sent) {
this->onMessageSendRequested(channel, msg, sent);
@ -91,6 +92,8 @@ void TwitchServer::privateMessageReceived(Communi::IrcPrivateMessage *message)
void TwitchServer::messageReceived(Communi::IrcMessage *message)
{
qDebug() << message->toData();
// this->readConnection
if (message->type() == Communi::IrcMessage::Type::Private) {
// We already have a handler for private messages
@ -179,6 +182,12 @@ QString TwitchServer::cleanChannelName(const QString &dirtyChannelName)
return dirtyChannelName.toLower();
}
bool TwitchServer::hasSeparateWriteConnection() const
{
return true;
// return getSettings()->twitchSeperateWriteConnection;
}
void TwitchServer::onMessageSendRequested(TwitchChannel *channel, const QString &message,
bool &sent)
{

21
src/providers/twitch/TwitchServer.hpp
View file

@ -22,7 +22,6 @@ public:
virtual void initialize(Application &app) override;
// fourtf: ugh
void forEachChannelAndSpecialChannels(std::function<void(ChannelPtr)> func);
std::shared_ptr<Channel> getChannelOrEmptyByID(const QString &channelID);
@ -36,16 +35,18 @@ public:
PubSub *pubsub;
protected:
void initializeConnection(IrcConnection *connection, bool isRead, bool isWrite) override;
std::shared_ptr<Channel> createChannel(const QString &channelName) override;
virtual void initializeConnection(IrcConnection *connection, bool isRead,
bool isWrite) override;
virtual std::shared_ptr<Channel> createChannel(const QString &channelName) override;
void privateMessageReceived(Communi::IrcPrivateMessage *message) override;
void messageReceived(Communi::IrcMessage *message) override;
void writeConnectionMessageReceived(Communi::IrcMessage *message) override;
virtual void privateMessageReceived(Communi::IrcPrivateMessage *message) override;
virtual void messageReceived(Communi::IrcMessage *message) override;
virtual void writeConnectionMessageReceived(Communi::IrcMessage *message) override;
std::shared_ptr<Channel> getCustomChannel(const QString &channelname) override;
virtual std::shared_ptr<Channel> getCustomChannel(const QString &channelname) override;
QString cleanChannelName(const QString &dirtyChannelName) override;
virtual QString cleanChannelName(const QString &dirtyChannelName) override;
virtual bool hasSeparateWriteConnection() const override;
private:
void onMessageSendRequested(TwitchChannel *channel, const QString &message, bool &sent);
@ -57,6 +58,10 @@ private:
std::queue<std::chrono::steady_clock::time_point> lastMessageMod_;
std::chrono::steady_clock::time_point lastErrorTimeSpeed_;
std::chrono::steady_clock::time_point lastErrorTimeAmount_;
bool singleConnection_ = false;
pajlada::Signals::SignalHolder signalHolder_;
};
} // namespace chatterino

2
src/singletons/Settings.hpp
View file

@ -52,6 +52,8 @@ public:
BoolSetting showJoins = {"/behaviour/showJoins", false};
BoolSetting showParts = {"/behaviour/showParts", false};
FloatSetting mouseScrollMultiplier = {"/behaviour/mouseScrollMultiplier", 1.0};
// BoolSetting twitchSeperateWriteConnection = {"/behaviour/twitchSeperateWriteConnection",
// false};
// Auto-completion
BoolSetting onlyFetchChattersForSmallerStreamers = {

3
src/util/DebugCount.cpp
View file

@ -2,7 +2,6 @@
namespace chatterino {
QMap<QString, int64_t> DebugCount::counts_;
std::mutex DebugCount::mut_;
UniqueAccess<QMap<QString, int64_t>> DebugCount::counts_;
} // namespace chatterino

25
src/util/DebugCount.hpp
View file

@ -1,5 +1,7 @@
#pragma once
#include <common/UniqueAccess.hpp>
#include <mutex>
#include <typeinfo>
@ -13,11 +15,11 @@ class DebugCount
public:
static void increase(const QString &name)
{
std::lock_guard<std::mutex> lock(mut_);
auto counts = counts_.access();
auto it = counts_.find(name);
if (it == counts_.end()) {
counts_.insert(name, 1);
auto it = counts->find(name);
if (it == counts->end()) {
counts->insert(name, 1);
} else {
reinterpret_cast<int64_t &>(it.value())++;
}
@ -25,11 +27,11 @@ public:
static void decrease(const QString &name)
{
std::lock_guard<std::mutex> lock(mut_);
auto counts = counts_.access();
auto it = counts_.find(name);
if (it == counts_.end()) {
counts_.insert(name, -1);
auto it = counts->find(name);
if (it == counts->end()) {
counts->insert(name, -1);
} else {
reinterpret_cast<int64_t &>(it.value())--;
}
@ -37,10 +39,10 @@ public:
static QString getDebugText()
{
std::lock_guard<std::mutex> lock(mut_);
auto counts = counts_.access();
QString text;
for (auto it = counts_.begin(); it != counts_.end(); it++) {
for (auto it = counts->begin(); it != counts->end(); it++) {
text += it.key() + ": " + QString::number(it.value()) + "\n";
}
return text;
@ -52,8 +54,7 @@ public:
}
private:
static QMap<QString, int64_t> counts_;
static std::mutex mut_;
static UniqueAccess<QMap<QString, int64_t>> counts_;
};
} // namespace chatterino

2
src/widgets/helper/DebugPopup.cpp
View file

@ -15,7 +15,7 @@ DebugPopup::DebugPopup()
auto *text = new QLabel(this);
auto *timer = new QTimer(this);
timer->setInterval(1000);
timer->setInterval(300);
QObject::connect(timer, &QTimer::timeout,
[text] { text->setText(DebugCount::getDebugText()); });
timer->start();

2
src/widgets/helper/DebugPopup.hpp
View file

@ -1,6 +1,6 @@
#pragma once
#include <QWindow>
#include <QWidget>
namespace chatterino {

2
src/widgets/settingspages/FeelPage.cpp
View file

@ -24,6 +24,8 @@ FeelPage::FeelPage()
auto layout = layoutCreator.setLayoutType<QVBoxLayout>();
// layout.append(this->createCheckBox("Use a seperate write connection.",
// getSettings()->twitchSeperateWriteConnection));
layout.append(this->createCheckBox(SCROLL_SMOOTH, getSettings()->enableSmoothScrolling));
layout.append(
this->createCheckBox(SCROLL_NEWMSG, getSettings()->enableSmoothScrollingNewMessages));