blue/jay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored in a way modules have access to bot infrastructure

Browse Source
This commit is contained in:
Blue 2025-03-09 21:01:41 +02:00
parent c605b3ba93
commit 89c04254b8
Signed by: blue
GPG Key ID: 9B203B252A63EE38
25 changed files with 245 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -19,7 +19,7 @@ set(EXEC_NAME "jay")
add_executable(${EXEC_NAME} main.cpp jay.cpp)
add_subdirectory(component)
add_subdirectory(handler)
add_subdirectory(connection)
add_subdirectory(module)
target_include_directories(${EXEC_NAME} PRIVATE ${GLOOX_INCLUDE_DIRS})

2
component/CMakeLists.txt
View File

@ -3,6 +3,7 @@ set(SOURCES
logger.cpp
actor.cpp
router.cpp
core.cpp
)
set(HEADERS
@ -10,6 +11,7 @@ set(HEADERS
logger.h
actor.h
router.h
core.h
)
target_sources(${EXEC_NAME} PRIVATE ${SOURCES})

4
component/actor.cpp
View File

@ -11,3 +11,7 @@ Actor::Actor(const std::string& jid, const std::string& group) :
void Actor::setGroup(const std::string& newGroup) {
group = newGroup;
}
std::string Actor::getGroup() const {
return group;
}

1
component/actor.h
View File

@ -10,6 +10,7 @@ public:
Actor(const std::string& jid, const std::string& group);
void setGroup(const std::string& newGroup);
std::string getGroup() const;
public:
const std::string jid;

2
component/config.cpp
View File

@ -46,7 +46,7 @@ gloox::TLSPolicy Config::getTLSPolicy() const {
}
std::map<std::string, std::string> Config::getOwners() const {
std::map<std::string, std::string> Config::getActors() const {
std::map<std::string, std::string> result;
YAML::Node owners = root["actors"];
if (!owners.IsMap())

2
component/config.h
View File

@ -30,7 +30,7 @@ public:
std::string getFullJID() const;
std::string getPassword() const;
std::string getResource() const;
std::map<std::string, std::string> getOwners() const;
std::map<std::string, std::string> getActors() const;
gloox::LogLevel getLogLevel() const;
gloox::TLSPolicy getTLSPolicy() const;
Module getModuleConfig(const std::string& name) const;

10
component/core.cpp Normal file
View File

@ -0,0 +1,10 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "core.h"
Core::Core(const std::string& configPath):
config(configPath),
router(),
logger()
{}

20
component/core.h Normal file
View File

@ -0,0 +1,20 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <string>
#include "config.h"
#include "router.h"
#include "logger.h"
class Core {
public:
Core(const std::string& configPath);
Config config;
Router router;
Logger logger;
};

11
component/logger.cpp
View File

@ -78,15 +78,10 @@ void writeTags(gloox::LogArea area) {
std::cout << '\t';
}
Logger::Logger(gloox::LogSink& sink, gloox::LogLevel level):
sink(sink)
{
sink.registerLogHandler(level, gloox::LogAreaAll, this);
}
Logger::Logger()
{}
Logger::~Logger() {
sink.removeLogHandler(this);
}
Logger::~Logger() {}
void Logger::handleLog(gloox::LogLevel level, gloox::LogArea area, const std::string& message) {
writeTimestamp();

9
component/logger.h
View File

@ -6,15 +6,10 @@
#include <gloox/loghandler.h>
#include <gloox/logsink.h>
class Logger : public gloox::LogHandler {
class Logger: public gloox::LogHandler {
public:
Logger(gloox::LogSink& sink, gloox::LogLevel level);
Logger();
~Logger();
void handleLog(gloox::LogLevel level, gloox::LogArea area, const std::string& message) override;
private:
gloox::LogSink& sink;
gloox::LogLevel level;
};

11
component/router.cpp
View File

@ -3,6 +3,8 @@
#include "router.h"
#include "module/module.h"
Router::Router():
actors(),
defaultGroup("Stranger")
@ -43,4 +45,13 @@ void Router::routeMessage(const std::string& sender, const std::string& body) {
module->message(aItr->second, args);
}
std::map<std::string, std::string> Router::getActors() const {
std::map<std::string, std::string> result;
for (const std::pair<const std::string, std::shared_ptr<Actor>>& pair : actors)
result.emplace(pair.first, pair.second->getGroup());
return result;
}

7
component/router.h
View File

@ -9,7 +9,10 @@
#include <memory>
#include "actor.h"
#include "module/module.h"
namespace Module {
class Module;
};
class Router {
public:
@ -19,6 +22,8 @@ public:
void registerActor(const std::string& key, const std::string& group);
void routeMessage(const std::string& sender, const std::string& body);
std::map<std::string, std::string> getActors() const;
private:
typedef std::map<std::string, std::weak_ptr<Module::Module>> Modules;
typedef std::map<std::string, std::shared_ptr<Actor>> Actors;

2
handler/CMakeLists.txt → connection/CMakeLists.txt
View File

@ -1,10 +1,8 @@
set(SOURCES
message.cpp
connection.cpp
)
set(HEADERS
message.h
connection.h
)

71
connection/connection.cpp Normal file
View File

@ -0,0 +1,71 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "connection.h"
Connection::Connection(const std::shared_ptr<Core>& core):
state(initial),
core(core),
gloox()
{}
Connection::~Connection() noexcept {
deinitialize();
}
void Connection::initiialize() {
if (state != initial)
return;
gloox = std::make_unique<gloox::Client>(core->config.getFullJID(), core->config.getPassword());
gloox->registerConnectionListener(this);
gloox->registerMessageHandler(this);
gloox->logInstance().registerLogHandler(core->config.getLogLevel(), gloox::LogAreaAll, &core->logger);
gloox::Disco* disco = gloox->disco();
disco->setVersion("Jay", "0.0.1");
disco->setIdentity("client", "bot");
gloox->setTls(core->config.getTLSPolicy());
gloox->setSASLMechanisms(gloox::SaslMechAll);
gloox->setStreamManagement(true, true);
state = disconnected;
}
void Connection::deinitialize() {
if (state == initial)
return;
gloox->logInstance().removeLogHandler(&core->logger);
gloox->removeMessageHandler(this);
gloox->removeConnectionListener(this);
gloox = nullptr;
state = initial;
}
void Connection::connect() {
if (state != disconnected)
return;
state = connected;
gloox->connect(true);
state = disconnected;
}
void Connection::send(const std::string& jid, const std::string& body) {
gloox->send(gloox::Message(gloox::Message::Chat, jid, body));
}
void Connection::handleMessage(const gloox::Message& message, gloox::MessageSession* session) {
core->router.routeMessage(message.from().bare(), message.body());
}
void Connection::onConnect() {}
void Connection::onDisconnect(gloox::ConnectionError e) {}
bool Connection::onTLSConnect(const gloox::CertInfo&) { return true; }

47
connection/connection.h Normal file
View File

@ -0,0 +1,47 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <memory>
#include <gloox/client.h>
#include <gloox/message.h>
#include <gloox/disco.h>
#include <gloox/connectionlistener.h>
#include <gloox/messagehandler.h>
#include "component/core.h"
class Connection:
public gloox::ConnectionListener,
public gloox::MessageHandler
{
public:
enum State {
initial,
disconnected,
connected
};
public:
Connection(const std::shared_ptr<Core>& core);
~Connection() noexcept;
void initiialize();
void deinitialize();
void connect();
void send(const std::string& jid, const std::string& body);
public:
void onConnect() override;
void onDisconnect(gloox::ConnectionError e) override;
bool onTLSConnect(const gloox::CertInfo&) override;
void handleMessage(const gloox::Message& message, gloox::MessageSession* session = 0) override;
private:
State state;
std::shared_ptr<Core> core;
std::unique_ptr<gloox::Client> gloox;
};

27
handler/connection.cpp
View File

@ -1,27 +0,0 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "connection.h"
Connection::Connection(const std::shared_ptr<Config>& config, const std::shared_ptr<gloox::Client>& client):
config(config),
client(client)
{
client->registerConnectionListener(this);
}
Connection::~Connection() {
if (std::shared_ptr<gloox::Client> cl = client.lock())
cl->removeConnectionListener(this);
}
void Connection::onConnect() {}
void Connection::onDisconnect(gloox::ConnectionError e) {}
bool Connection::onTLSConnect(const gloox::CertInfo& info) {
return true;
}

25
handler/connection.h
View File

@ -1,25 +0,0 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <memory>
#include "gloox/client.h"
#include "gloox/connectionlistener.h"
#include "component/config.h"
class Connection : public gloox::ConnectionListener {
public:
Connection(const std::shared_ptr<Config>& config, const std::shared_ptr<gloox::Client>& client);
~Connection();
void onConnect() override;
void onDisconnect(gloox::ConnectionError e) override;
bool onTLSConnect(const gloox::CertInfo&) override;
private:
std::weak_ptr<Config> config;
std::weak_ptr<gloox::Client> client;
};

23
handler/message.cpp
View File

@ -1,23 +0,0 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#include "message.h"
#include <iostream>
Message::Message(const std::shared_ptr<Config>& config, const std::shared_ptr<gloox::Client>& client, const Callback& callback):
callback(callback),
config(config),
client(client)
{
client->registerMessageHandler(this);
}
Message::~Message() {
if (std::shared_ptr<gloox::Client> cl = client.lock())
cl->removeMessageHandler(this);
}
void Message::handleMessage(const gloox::Message& message, gloox::MessageSession* session) {
callback(message.from().bare(), message.body());
}

30
handler/message.h
View File

@ -1,30 +0,0 @@
// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include <string>
#include <memory>
#include <functional>
#include <gloox/client.h>
#include <gloox/messagehandler.h>
#include <gloox/message.h>
#include "component/config.h"
class Message : public gloox::MessageHandler {
private:
typedef std::function<void (const std::string&, const std::string&)> Callback;
public:
Message(const std::shared_ptr<Config>& config, const std::shared_ptr<gloox::Client>& client, const Callback& callback);
~Message();
void handleMessage(const gloox::Message& message, gloox::MessageSession* session = 0) override;
private:
Callback callback;
std::weak_ptr<Config> config;
std::weak_ptr<gloox::Client> client;
};

81
jay.cpp
View File

@ -5,86 +5,55 @@
#include "module/actor.h"
static const std::map<std::string, std::function<std::shared_ptr<Module::Module>(const std::shared_ptr<gloox::Client>)>> moduleNames = {
{"actor", [](const std::shared_ptr<gloox::Client> client) { return std::make_shared<Module::Actor>(client); }}
static const std::map<
std::string,
std::function<
std::shared_ptr<Module::Module>(
const std::shared_ptr<Core>&,
const std::shared_ptr<Connection>&
)
>
> moduleNames = {
{"actor", [](const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection) { return std::make_shared<Module::Actor>(core, connection); }}
};
Jay::Jay(const std::string& configPath):
runMutex(),
config(std::make_shared<Config>(configPath)),
router(std::make_unique<Router>()),
client(),
messageHandler(),
connectionHandler(),
modules(),
loggers()
core(std::make_shared<Core>(configPath)),
connection(std::make_shared<Connection>(core)),
modules()
{}
Jay::~Jay() {}
bool Jay::isConfigValid() const {
return config->isValid();
Jay::~Jay() {
connection->deinitialize();
}
bool Jay::isConfigValid() const {
return core->config.isValid();
}
void Jay::run() {
std::lock_guard lock(runMutex);
initialize();
client->connect(true);
connection->connect();
}
void Jay::initialize() {
createClient();
if (!messageHandler)
messageHandler = std::make_unique<Message>(
config,
client,
std::bind(&Router::routeMessage, router.get(), std::placeholders::_1, std::placeholders::_2)
);
if (!connectionHandler)
connectionHandler = std::make_unique<Connection>(config, client);
connection->initiialize();
createModules();
createActors();
}
void Jay::createClient() {
if (client)
return;
client = std::make_shared<gloox::Client>(config->getFullJID(), config->getPassword());
addLogger(config->getLogLevel());
gloox::Disco* disco = client->disco();
disco->setVersion("Jay", "0.0.1");
disco->setIdentity("client", "bot");
client->setTls(config->getTLSPolicy());
client->setSASLMechanisms(gloox::SaslMechAll);
client->setStreamManagement(true, true);
}
void Jay::createActors() {
for (const std::pair<const std::string, std::string>& pair : config->getOwners())
router->registerActor(pair.first, pair.second);
for (const std::pair<const std::string, std::string>& pair : core->config.getActors())
core->router.registerActor(pair.first, pair.second);
}
void Jay::createModules() {
for (const auto& pair : moduleNames) {
Config::Module conf = config->getModuleConfig(pair.first);
Config::Module conf = core->config.getModuleConfig(pair.first);
if (!conf.enabled)
continue;
modules.emplace_back(pair.second(client));
router->registerModule(pair.first, modules.back());
modules.emplace_back(pair.second(core, connection));
core->router.registerModule(pair.first, modules.back());
}
}
void Jay::addLogger(gloox::LogLevel level) {
loggers.emplace_back(std::make_unique<Logger>(client->logInstance(), level));
}

20
jay.h
View File

@ -7,17 +7,14 @@
#include <iostream>
#include <vector>
#include <memory>
#include <mutex>
#include <functional>
#include <gloox/client.h>
#include <gloox/disco.h>
#include <gloox/connectionlistener.h>
#include "component/logger.h"
#include "component/config.h"
#include "component/router.h"
#include "handler/message.h"
#include "handler/connection.h"
#include "component/core.h"
#include "connection/connection.h"
#include "module/module.h"
class Jay {
@ -30,19 +27,12 @@ public:
void run();
private:
void addLogger(gloox::LogLevel level);
void initialize();
void createClient();
void createActors();
void createModules();
private:
std::mutex runMutex;
std::shared_ptr<Config> config;
std::unique_ptr<Router> router;
std::shared_ptr<gloox::Client> client;
std::unique_ptr<Message> messageHandler;
std::unique_ptr<Connection> connectionHandler;
std::shared_ptr<Core> core;
std::shared_ptr<Connection> connection;
std::vector<std::shared_ptr<Module::Module>> modules;
std::vector<std::unique_ptr<Logger>> loggers;
};

26
module/actor.cpp
View File

@ -3,13 +3,33 @@
#include "actor.h"
Module::Actor::Actor(const std::shared_ptr<gloox::Client>& client):
Module(client)
Module::Actor::Actor(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection):
Module(core, connection)
{}
Module::Actor::~Actor() noexcept {}
void Module::Actor::message(const std::shared_ptr<::Actor>& actor, const Module::Module::Tokens& args) {
std::string result;
if (args.front() == "list")
sendMessage(actor, "Me\nMyself\nI");
result = list();
if (!result.empty())
connection->send(actor->jid, result);
}
std::string Module::Actor::list() {
std::string result;
for (const std::pair<const std::string, std::string>& pair : core->router.getActors()) {
if (!result.empty())
result.append(1, '\n');
result += pair.first + ": " + pair.second;
}
if (result.empty())
result += "There are no actors currently";
return result;
}

5
module/actor.h
View File

@ -9,10 +9,13 @@ namespace Module {
class Actor : public Module {
public:
Actor(const std::shared_ptr<gloox::Client>& client);
Actor(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection);
~Actor() noexcept;
virtual void message(const std::shared_ptr<::Actor>& actor, const Tokens& args) override;
private:
std::string list();
};
}

13
module/module.cpp
View File

@ -5,8 +5,9 @@
#include "gloox/message.h"
Module::Module::Module(const std::shared_ptr<gloox::Client>& client):
client(client)
Module::Module::Module(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection):
core(core),
connection(connection)
{}
Module::Module::~Module() noexcept {}
@ -25,11 +26,3 @@ std::vector<std::string> Module::Module::split(const std::string& string, const
return result;
}
void Module::Module::sendMessage(const std::shared_ptr<Actor>& actor, const std::string& body) {
client->send(gloox::Message(
gloox::Message::Chat,
actor->jid,
body
));
}

10
module/module.h
View File

@ -7,9 +7,9 @@
#include <memory>
#include <vector>
#include "gloox/client.h"
#include "component/core.h"
#include "component/actor.h"
#include "connection/connection.h"
namespace Module {
@ -18,8 +18,7 @@ public:
typedef std::vector<std::string> Tokens;
protected:
Module(const std::shared_ptr<gloox::Client>& client);
void sendMessage(const std::shared_ptr<Actor>& actor, const std::string& body);
Module(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection);
public:
virtual ~Module() noexcept;
@ -29,7 +28,8 @@ public:
virtual void message(const std::shared_ptr<Actor>& actor, const Tokens& args) = 0;
protected:
std::shared_ptr<gloox::Client> client;
std::shared_ptr<Core> core;
std::shared_ptr<Connection> connection;
};