squawk/core/delayManager/manager.cpp

438 lines
13 KiB
C++
Raw Normal View History

2023-03-04 22:36:53 +00:00
// Squawk messenger.
// Copyright (C) 2019 Yury Gubich <blue@macaw.me>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "manager.h"
#include <QDebug>
2023-03-04 22:36:53 +00:00
#include "cardinternal.h"
#include "infoforuser.h"
#include "owncardinternal.h"
#include "owninfoforuser.h"
Core::DelayManager::Manager::Manager(const QString& poj, Job::Id mpj, QObject* parent) :
2023-03-04 22:36:53 +00:00
QObject(parent),
maxParallelJobs(mpj),
nextJobId(1),
scheduledJobs(),
scheduledJobsById(scheduledJobs.get<id>()),
jobSequence(scheduledJobs.get<sequence>()),
runningJobs(),
ownVCardJobId(0),
ownInfoJobId(0),
scheduledVCards(),
requestedVCards(),
2023-03-07 18:45:01 +00:00
#ifdef WITH_OMEMO
requestedBundles(),
2023-03-07 18:45:01 +00:00
#endif
ownJid(poj)
2023-03-04 22:36:53 +00:00
{
}
2023-03-07 18:45:01 +00:00
Core::DelayManager::Manager::~Manager() {
for (const std::pair<const Job::Id, Job*>& pair : runningJobs) {
delete pair.second;
}
for (Job* job : jobSequence) {
delete job;
}
}
2023-03-04 22:36:53 +00:00
Core::DelayManager::Job::Id Core::DelayManager::Manager::getNextJobId() {
2023-03-04 22:36:53 +00:00
Job::Id id = nextJobId++;
if (id == 0)
id = nextJobId++;
return id;
}
2023-03-07 18:45:01 +00:00
void Core::DelayManager::Manager::getInfo(const QString& jid) {
if (jid == ownJid)
return getOwnInfo();
2023-03-04 22:36:53 +00:00
Job* job = nullptr;
#ifdef WITH_OMEMO
std::map<QString, Job::Id>::const_iterator bitr = requestedBundles.find(jid);
if (bitr != requestedBundles.end()) {
std::map<Job::Id, Job*>::const_iterator itr = runningJobs.find(bitr->second);
if (itr == runningJobs.end())
throw JobNotFound(bitr->second);
job = itr->second;
}
2023-03-04 22:36:53 +00:00
else
#endif
job = getVCardJob(jid);
if (job != nullptr) {
2023-03-07 18:45:01 +00:00
if (job->type == Job::Type::cardInternal)
2023-03-04 22:36:53 +00:00
replaceJob(new InfoForUser(job->id, jid));
} else
scheduleJob(new InfoForUser(getNextJobId(), jid));
}
2023-03-07 18:45:01 +00:00
void Core::DelayManager::Manager::getOwnInfo() {
2023-03-04 22:36:53 +00:00
if (ownInfoJobId == 0) {
if (ownVCardJobId != 0)
replaceJob(new OwnInfoForUser(ownVCardJobId));
else
scheduleJob(new OwnInfoForUser(getNextJobId()));
}
}
2023-03-07 18:45:01 +00:00
void Core::DelayManager::Manager::getVCard(const QString& jid) {
2023-03-04 22:36:53 +00:00
Job* job = getVCardJob(jid);
if (job == nullptr)
scheduleJob(new CardInternal(getNextJobId(), jid));
}
2023-03-07 18:45:01 +00:00
void Core::DelayManager::Manager::getOwnVCard() {
if (ownVCardJobId == 0)
2023-03-04 22:36:53 +00:00
scheduleJob(new OwnCardInternal(getNextJobId()));
}
bool Core::DelayManager::Manager::isOwnVCardPending() const {
return ownVCardJobId != 0;
}
Core::DelayManager::Job* Core::DelayManager::Manager::getVCardJob(const QString& jid) {
2023-03-04 22:36:53 +00:00
Job* job = nullptr;
std::map<QString, Job::Id>::const_iterator sitr = scheduledVCards.find(jid);
if (sitr == scheduledVCards.end()) {
std::map<QString, Job::Id>::const_iterator ritr = requestedVCards.find(jid);
if (ritr != requestedVCards.end()) {
std::map<Job::Id, Job*>::const_iterator itr = runningJobs.find(ritr->second);
if (itr == runningJobs.end())
throw JobNotFound(ritr->second, "getVCardJob:1");
job = itr->second;
}
2023-03-04 22:36:53 +00:00
} else {
StorageById::const_iterator itr = scheduledJobsById.find(sitr->second);
if (itr == scheduledJobsById.end())
throw JobNotFound(sitr->second, "getVCardJob:2");
job = *itr;
2023-03-04 22:36:53 +00:00
}
return job;
}
void Core::DelayManager::Manager::preScheduleJob(Job* job) {
2023-03-07 18:45:01 +00:00
switch (job->type) {
2023-03-04 22:36:53 +00:00
case Job::Type::cardInternal:
2023-03-07 18:45:01 +00:00
scheduledVCards.emplace(dynamic_cast<CardInternal*>(job)->jid, job->id);
2023-03-04 22:36:53 +00:00
break;
case Job::Type::ownCardInternal:
ownVCardJobId = job->id;
break;
case Job::Type::infoForUser:
2023-03-07 18:45:01 +00:00
scheduledVCards.emplace(dynamic_cast<InfoForUser*>(job)->jid, job->id);
2023-03-04 22:36:53 +00:00
break;
case Job::Type::ownInfoForUser:
ownVCardJobId = job->id;
ownInfoJobId = job->id;
break;
}
}
void Core::DelayManager::Manager::scheduleJob(Job* job) {
2023-03-04 22:36:53 +00:00
preScheduleJob(job);
if (runningJobs.size() < maxParallelJobs) {
executeJob(job);
} else {
scheduledJobs.push_back(job);
}
}
void Core::DelayManager::Manager::preExecuteJob(Job* job) {
2023-03-07 18:45:01 +00:00
switch (job->type) {
2023-03-04 22:36:53 +00:00
case Job::Type::cardInternal:
case Job::Type::infoForUser: {
2023-03-07 18:45:01 +00:00
Contact* cij = dynamic_cast<Contact*>(job);
2023-03-04 22:36:53 +00:00
requestedVCards.emplace(cij->jid, job->id);
scheduledVCards.erase(cij->jid);
}
break;
case Job::Type::ownInfoForUser:
case Job::Type::ownCardInternal:
break;
}
}
void Core::DelayManager::Manager::executeJob(Job* job) {
2023-03-04 22:36:53 +00:00
preExecuteJob(job);
runningJobs.emplace(job->id, job);
2023-03-07 18:45:01 +00:00
switch (job->type) {
2023-03-04 22:36:53 +00:00
case Job::Type::cardInternal:
case Job::Type::infoForUser:
2023-03-07 18:45:01 +00:00
emit requestVCard(dynamic_cast<Contact*>(job)->jid);
2023-03-04 22:36:53 +00:00
break;
case Job::Type::ownInfoForUser:
case Job::Type::ownCardInternal:
emit requestOwnVCard();
break;
}
}
2023-03-07 18:45:01 +00:00
void Core::DelayManager::Manager::jobIsDone(Job::Id jobId) {
2023-03-04 22:36:53 +00:00
std::map<Job::Id, Job*>::const_iterator itr = runningJobs.find(jobId);
if (itr == runningJobs.end()) {
throw JobNotFound(jobId, "jobIsDone");
2023-03-04 22:36:53 +00:00
}
Job* job = itr->second;
delete job;
runningJobs.erase(itr);
if (scheduledJobs.size() > 0) {
Job* job = scheduledJobs.front();
scheduledJobs.pop_front();
executeJob(job);
}
}
void Core::DelayManager::Manager::replaceJob(Job* job) {
2023-03-04 22:36:53 +00:00
preScheduleJob(job);
std::map<Job::Id, Job*>::iterator itr = runningJobs.find(job->id);
if (itr != runningJobs.end()) {
preExecuteJob(job);
delete itr->second;
itr->second = job;
} else {
StorageById::iterator sitr = scheduledJobsById.find(job->id);
if (sitr != scheduledJobsById.end()) {
delete *(sitr);
scheduledJobsById.replace(sitr, job);
} else
throw JobNotFound(job->id, "replaceJob");
2023-03-04 22:36:53 +00:00
}
}
void Core::DelayManager::Manager::jobIsCanceled(Job* job, bool wasRunning) {
2023-03-07 18:45:01 +00:00
switch (job->type) {
case Job::Type::cardInternal: {
CardInternal* jb = dynamic_cast<CardInternal*>(job);
if (wasRunning)
requestedVCards.erase(jb->jid);
else
scheduledVCards.erase(jb->jid);
emit gotVCard(jb->jid, Shared::VCard());
2023-03-07 18:45:01 +00:00
}
break;
case Job::Type::infoForUser: {
InfoForUser* jb = dynamic_cast<InfoForUser*>(job);
switch (jb->getStage()) {
case InfoForUser::Stage::waitingForVCard:
if (wasRunning)
requestedVCards.erase(jb->jid);
else
scheduledVCards.erase(jb->jid);
2023-03-07 18:45:01 +00:00
emit gotVCard(jb->jid, Shared::VCard());
break;
case InfoForUser::Stage::waitingForBundles:
requestedBundles.erase(jb->jid);
break;
default:
break;
2023-03-07 18:45:01 +00:00
}
emit gotInfo(Shared::Info(jb->jid));
2023-03-07 18:45:01 +00:00
}
break;
case Job::Type::ownInfoForUser: {
OwnInfoForUser* jb = dynamic_cast<OwnInfoForUser*>(job);
if (jb->getStage() == OwnInfoForUser::Stage::waitingForVCard) {
ownVCardJobId = 0;
emit gotOwnVCard(Shared::VCard());
2023-03-07 18:45:01 +00:00
}
ownInfoJobId = 0;
emit gotOwnInfo(Shared::Info (ownJid));
2023-03-07 18:45:01 +00:00
}
break;
case Job::Type::ownCardInternal:
ownVCardJobId = 0;
emit gotOwnVCard(Shared::VCard());
2023-03-07 18:45:01 +00:00
break;
}
delete job;
}
void Core::DelayManager::Manager::disconnected() {
for (const std::pair<const Job::Id, Job*> pair : runningJobs)
jobIsCanceled(pair.second, true);
for (Job* job : scheduledJobs)
jobIsCanceled(job, false);
runningJobs.clear();
scheduledJobs.clear();
}
void Core::DelayManager::Manager::receivedVCard(const QString& jid, const Shared::VCard& card) {
2023-03-04 22:36:53 +00:00
std::map<QString, Job::Id>::const_iterator cardItr = requestedVCards.find(jid);
if (cardItr == requestedVCards.end()) {
qDebug() << "received VCard for" << jid << "but it was never requested through manager, ignoring";
return;
}
Job::Id jobId = cardItr->second;
requestedVCards.erase(cardItr);
std::map<Job::Id, Job*>::const_iterator itr = runningJobs.find(jobId);
if (itr == runningJobs.end()) {
throw JobNotFound(jobId, "receivedVCard");
}
Job* job = itr->second;
switch (job->type) {
case Job::Type::cardInternal:
jobIsDone(jobId);
emit gotVCard(jid, card);
break;
case Job::Type::infoForUser: {
2023-03-04 22:36:53 +00:00
#ifdef WITH_OMEMO
requestedBundles.emplace(jid, jobId);
InfoForUser* jb = dynamic_cast<InfoForUser*>(job);
jb->receivedVCard(card);
emit requestBundles(jid);
2023-03-04 22:36:53 +00:00
#else
Shared::Info info(jid);
info.turnIntoContact(card);
emit gotInfo(info);
jobIsDone(jobId);
2023-03-04 22:36:53 +00:00
#endif
emit gotVCard(jid, card);
2023-03-04 22:36:53 +00:00
}
break;
default:
throw UnexpectedJobType(job->type, "receivedVCard");
2023-03-04 22:36:53 +00:00
}
}
void Core::DelayManager::Manager::receivedOwnVCard(const Shared::VCard& card) {
if (ownVCardJobId == 0) {
qDebug() << "received own VCard for" << ownJid << "but it was never requested through manager, ignoring";
return;
}
2023-03-04 22:36:53 +00:00
Job::Id jobId = ownVCardJobId;
ownVCardJobId = 0;
std::map<Job::Id, Job*>::const_iterator itr = runningJobs.find(jobId);
if (itr == runningJobs.end()) {
throw JobNotFound(jobId, "receivedOwnVCard");
}
Job* job = itr->second;
2023-03-07 18:45:01 +00:00
switch (job->type) {
2023-03-04 22:36:53 +00:00
case Job::Type::ownCardInternal:
jobIsDone(jobId);
emit gotOwnVCard(card);
2023-03-04 22:36:53 +00:00
break;
case Job::Type::ownInfoForUser: {
2023-03-04 22:36:53 +00:00
#ifdef WITH_OMEMO
OwnInfoForUser* jb = dynamic_cast<OwnInfoForUser*>(job);
jb->receivedVCard(card);
emit requestOwnBundles();
2023-03-04 22:36:53 +00:00
#else
Shared::Info info(ownJid);
info.turnIntoOwnAccount(card);
emit gotOwnInfo(info);
2023-03-04 22:36:53 +00:00
jobIsDone(jobId);
#endif
emit gotOwnVCard(card);
}
2023-03-04 22:36:53 +00:00
break;
default:
throw UnexpectedJobType(job->type, "receivedVCard");
2023-03-04 22:36:53 +00:00
}
}
void Core::DelayManager::Manager::receivedBundles(const QString& jid, const std::list<Shared::KeyInfo>& keys) {
std::map<QString, Job::Id>::const_iterator itr = requestedBundles.find(jid);
if (itr == requestedBundles.end()) {
qDebug() << "received bundles for" << jid << "but they were never requested through manager, ignoring";
return;
}
Job::Id jobId = itr->second;
requestedBundles.erase(itr);
std::map<Job::Id, Job*>::const_iterator jitr = runningJobs.find(jobId);
if (jitr == runningJobs.end()) {
throw JobNotFound(jobId, "receivedBundles");
}
Job* jb = jitr->second;
InfoForUser* job = dynamic_cast<InfoForUser*>(jb);
Shared::Info info(jid);
info.turnIntoContact(job->claim(), new std::list<Shared::KeyInfo>(keys));
emit gotInfo(info);
jobIsDone(jobId);
}
void Core::DelayManager::Manager::receivedOwnBundles(const std::list<Shared::KeyInfo>& keys) {
if (ownInfoJobId == 0) {
qDebug() << "received own bundles for" << ownJid << "but they were never requested through manager, ignoring";
return;
}
Job::Id jobId = ownInfoJobId;
ownInfoJobId = 0;
std::map<Job::Id, Job*>::const_iterator jitr = runningJobs.find(jobId);
if (jitr == runningJobs.end()) {
throw JobNotFound(jobId, "receivedOwnBundles");
}
Job* jb = jitr->second;
OwnInfoForUser* job = dynamic_cast<OwnInfoForUser*>(jb);
Shared::Info info(ownJid);
info.turnIntoOwnAccount(job->claim(), new std::list<Shared::KeyInfo>(keys));
emit gotOwnInfo(info);
jobIsDone(jobId);
}
2023-03-04 22:36:53 +00:00
void Core::DelayManager::Manager::setOwnJid(const QString& jid) {
ownJid = jid;
2023-03-04 22:36:53 +00:00
}
Core::DelayManager::Manager::UnexpectedJobType::UnexpectedJobType(Job::Type p_type, const std::string& p_method):
Exception(),
type(p_type),
method(p_method)
{}
std::string Core::DelayManager::Manager::UnexpectedJobType::getMessage() const{
std::string msg("Unexpected job type: ");
msg += Job::TypeString[static_cast<int>(type)];
if (method.size() > 0) {
msg += " in method " + method;
}
return msg;
}
Core::DelayManager::Manager::JobNotFound::JobNotFound(Job::Id p_id, const std::string& p_method) :
Exception(),
id(p_id),
method(p_method)
{}
std::string Core::DelayManager::Manager::JobNotFound::getMessage() const {
std::string msg("Job with id ");
msg += std::to_string(id);
msg += " was not found";
if (method.size() > 0) {
msg += " in method " + method;
}
return msg;
}