Refactored in a way modules have access to bot infrastructure

CMakeLists.txt

@@ -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})

component/CMakeLists.txt

@@ -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})

component/actor.cpp

@@ -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;
+}

component/actor.h

@@ -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;

component/config.cpp

@@ -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())

component/config.h

@@ -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;

component/core.cpp

@@ -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()
+{}

component/core.h

@@ -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;
+
+};

component/logger.cpp

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

component/logger.h

@@ -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;
 };

component/router.cpp

@@ -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;
+}
+
 

component/router.h

@@ -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;

connection/CMakeLists.txt

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

connection/connection.cpp

@@ -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; }
+
+

connection/connection.h

@@ -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;
+};
+

handler/connection.cpp

@@ -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;
-}
-
-

handler/connection.h

@@ -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;
-};

handler/message.cpp

@@ -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());
-}

handler/message.h

@@ -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;
-};

jay.cpp

@@ -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 = {
+static const std::map<
-    {"actor", [](const std::shared_ptr<gloox::Client> client) { return std::make_shared<Module::Actor>(client); }}
+    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(),
+    core(std::make_shared<Core>(configPath)),
-    config(std::make_shared<Config>(configPath)),
+    connection(std::make_shared<Connection>(core)),
-    router(std::make_unique<Router>()),
+    modules()
-    client(),
-    messageHandler(),
-    connectionHandler(),
-    modules(),
-    loggers()
 {}
 
-Jay::~Jay() {}
+Jay::~Jay() {
-
+    connection->deinitialize();
-bool Jay::isConfigValid() const {
-    return config->isValid();
 }
 
+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();
+    connection->initiialize();
-
-    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);
-
     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())
+    for (const std::pair<const std::string, std::string>& pair : core->config.getActors())
-        router->registerActor(pair.first, pair.second);
+        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));
+        modules.emplace_back(pair.second(core, connection));
-        router->registerModule(pair.first, modules.back());
+        core->router.registerModule(pair.first, modules.back());
     }
 }
-
-void Jay::addLogger(gloox::LogLevel level) {
-    loggers.emplace_back(std::make_unique<Logger>(client->logInstance(), level));
-}

jay.h

@@ -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/core.h"
-#include "component/config.h"
+#include "connection/connection.h"
-#include "component/router.h"
-#include "handler/message.h"
-#include "handler/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<Core> core;
-    std::shared_ptr<Config> config;
+    std::shared_ptr<Connection> connection;
-    std::unique_ptr<Router> router;
-    std::shared_ptr<gloox::Client> client;
-    std::unique_ptr<Message> messageHandler;
-    std::unique_ptr<Connection> connectionHandler;
     std::vector<std::shared_ptr<Module::Module>> modules;
-    std::vector<std::unique_ptr<Logger>> loggers;
 };

module/actor.cpp

@@ -3,13 +3,33 @@
 
 #include "actor.h"
 
-Module::Actor::Actor(const std::shared_ptr<gloox::Client>& client):
+Module::Actor::Actor(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection):
-    Module(client)
+    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;
 }

module/actor.h

@@ -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();
 };
 
 }

module/module.cpp

@@ -5,8 +5,9 @@
 
 #include "gloox/message.h"
 
-Module::Module::Module(const std::shared_ptr<gloox::Client>& client):
+Module::Module::Module(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection):
-    client(client)
+    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
-    ));
-}

module/module.h

@@ -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);
+    Module(const std::shared_ptr<Core>& core, const std::shared_ptr<Connection>& connection);
-    void sendMessage(const std::shared_ptr<Actor>& actor, const std::string& body);
 
 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;
 
 };