glguy/xbot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

migrate to signals2

Browse Source
This commit is contained in:
Eric Mertens 2025-01-22 23:49:48 -08:00
parent d11412e73f
commit 7665f4c0f5
13 changed files with 100 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
CMakeLists.txt
View File

@ -20,13 +20,6 @@ FetchContent_Declare(
)
FetchContent_MakeAvailable(tomlplusplus)
FetchContent_Declare(
eventpp
GIT_REPOSITORY https://github.com/wqking/eventpp.git
GIT_TAG v0.1.3
)
FetchContent_MakeAvailable(eventpp)
add_custom_command(
OUTPUT irc_commands.inc
COMMAND
@ -41,9 +34,14 @@ add_subdirectory(mybase64)
add_executable(xbot
main.cpp irc_commands.inc ircmsg.cpp settings.cpp connection.cpp
snote_thread.cpp watchdog_thread.cpp write_irc.cpp
ping_thread.cpp irc_parse_thread.cpp registration_thread.cpp
self_thread.cpp command_thread.cpp priv_thread.cpp
sasl_thread.cpp)
write_irc.cpp
registration_thread.cpp
ping_thread.cpp
snote_thread.cpp
self_thread.cpp
watchdog_thread.cpp
)
# command_thread.cpp priv_thread.cpp
# sasl_thread.cpp)
target_include_directories(xbot PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
target_link_libraries(xbot PRIVATE Boost::log Boost::headers tomlplusplus_tomlplusplus eventpp PkgConfig::LIBHS mybase64)
target_link_libraries(xbot PRIVATE Boost::log Boost::headers tomlplusplus_tomlplusplus PkgConfig::LIBHS mybase64)

23
connection.cpp
View File

@ -4,6 +4,10 @@
#include <boost/log/trivial.hpp>
namespace {
#include "irc_commands.inc"
} // namespace
Connection::Connection(boost::asio::io_context & io)
: stream_{io}
, write_timer_{io, std::chrono::steady_clock::time_point::max()}
@ -72,7 +76,7 @@ auto Connection::connect(
auto const endpoints = co_await resolver.async_resolve(host, port, boost::asio::use_awaitable);
auto const endpoint = co_await boost::asio::async_connect(stream_, endpoints, boost::asio::use_awaitable);
make_event<ConnectEvent>();
sig_connect();
}
self->writer();
@ -86,11 +90,24 @@ auto Connection::connect(
}
buffer.add_bytes(n, [this](char * line) {
BOOST_LOG_TRIVIAL(debug) << "RECV: " << line;
make_event<LineEvent>(line);
auto const msg = parse_irc_message(line);
auto const recognized = IrcCommandHash::in_word_set(msg.command.data(), msg.command.size());
auto const command
= recognized
&& recognized->min_args <= msg.args.size()
&& recognized->max_args >= msg.args.size()
? recognized->command : IrcCommand::UNKNOWN;
if (IrcCommand::UNKNOWN == command)
{
BOOST_LOG_TRIVIAL(warning) << "Unrecognized command: " << msg.command << " " << msg.args.size();
}
sig_ircmsg(command, msg);
});
}
make_event<DisconnectEvent>();
sig_disconnect();
}
auto Connection::write_line(std::string message) -> void

64
connection.hpp
View File

@ -3,10 +3,8 @@
#include "event.hpp"
#include "settings.hpp"
#include <eventpp/eventdispatcher.h>
#include <eventpp/utilities/argumentadapter.h>
#include <boost/asio.hpp>
#include <boost/signals2.hpp>
#include <chrono>
#include <functional>
@ -20,43 +18,16 @@
#include <utility>
#include <variant>
#include <vector>
#include <typeinfo>
#include <typeindex>
struct ConnectEvent : Event
{
};
struct DisconnectEvent : Event
{
};
struct LineEvent : Event
{
explicit LineEvent(char * line) : line{line} {}
char * line;
};
#include "ircmsg.hpp"
#include "irc_command.hpp"
class Connection : public std::enable_shared_from_this<Connection>
{
using EventDispatcher = eventpp::EventDispatcher<std::type_index, void(Event&)>;
public:
template <typename T>
class Handle
{
EventDispatcher::Handle handle;
Handle(EventDispatcher::Handle handle) : handle{handle} {}
public:
Handle() : handle{} {}
friend Connection;
};
private:
boost::asio::ip::tcp::socket stream_;
boost::asio::steady_timer write_timer_;
std::list<std::string> write_strings_;
EventDispatcher dispatcher_;
auto writer() -> void;
auto writer_immediate() -> void;
@ -64,37 +35,14 @@ private:
public:
Connection(boost::asio::io_context & io);
template <typename T, typename F>
auto add_listener(F f) -> Handle<T>
{
return Handle<T>{dispatcher_.appendListener(
typeid(T),
eventpp::argumentAdapter<void(T&)>(f)
)};
}
template <typename T>
auto remove_listener(Handle<T> handle) -> void
{
dispatcher_.removeListener(typeid(T), handle.handle);
}
template <typename T>
auto dispatch(T& event) -> void
{
dispatcher_.dispatch(typeid(T), event);
}
boost::signals2::signal<void()> sig_connect;
boost::signals2::signal<void()> sig_disconnect;
boost::signals2::signal<void(IrcCommand, const IrcMsg &)> sig_ircmsg;
auto get_executor() -> boost::asio::any_io_executor {
return stream_.get_executor();
}
template <typename T, typename... Args>
auto make_event(Args&& ... args) {
auto event = T{std::forward<Args>(args)...};
dispatch<T>(event);
}
/// Write bytes into the socket. Messages should be properly newline terminated.
auto write_line(std::string message) -> void;

21
irc_parse_thread.hpp → irc_command.hpp
View File

@ -1,12 +1,3 @@
#pragma once
#include "event.hpp"
#include <string_view>
class Connection;
class IrcMsg;
enum class IrcCommand
{
UNKNOWN,
@ -284,15 +275,3 @@ enum class IrcCommand
SETNAME,
TOPIC,
};
struct IrcMsgEvent : Event
{
IrcMsgEvent(IrcCommand command, IrcMsg const& irc);
IrcCommand command;
IrcMsg const& irc;
};
struct IrcParseThread
{
static auto start(Connection& connection) -> void;
};

37
irc_parse_thread.cpp
View File

@ -1,37 +0,0 @@
#include "irc_parse_thread.hpp"
#include "connection.hpp"
#include "ircmsg.hpp"
#include <boost/log/trivial.hpp>
#include <cstring>
namespace {
#include "irc_commands.inc"
} // namespace
IrcMsgEvent::IrcMsgEvent(IrcCommand command, IrcMsg const& irc)
: command{command}, irc{irc} {}
auto IrcParseThread::start(Connection& connection) -> void
{
connection.add_listener<LineEvent>([&connection](LineEvent const& event)
{
auto const msg = parse_irc_message(event.line);
auto const recognized = IrcCommandHash::in_word_set(msg.command.data(), msg.command.size());
auto const command
= recognized
&& recognized->min_args <= msg.args.size()
&& recognized->max_args >= msg.args.size()
? recognized->command : IrcCommand::UNKNOWN;
if (IrcCommand::UNKNOWN == command)
{
BOOST_LOG_TRIVIAL(warning) << "Unrecognized command: " << msg.command << " " << msg.args.size();
}
connection.make_event<IrcMsgEvent>(command, msg);
});
}

48
main.cpp
View File

@ -6,15 +6,6 @@
#include "settings.hpp"
#include "write_irc.hpp"
#include "command_thread.hpp"
#include "irc_parse_thread.hpp"
#include "ping_thread.hpp"
#include "registration_thread.hpp"
#include "self_thread.hpp"
#include "snote_thread.hpp"
#include "watchdog_thread.hpp"
#include "priv_thread.hpp"
#include <boost/asio.hpp>
#include <algorithm>
@ -34,46 +25,37 @@
#include <unordered_map>
#include <unordered_set>
using namespace std::chrono_literals;
#include "ping_thread.hpp"
#include "registration_thread.hpp"
#include "self_thread.hpp"
#include "snote_thread.hpp"
auto echo_thread(
Connection& connection,
std::shared_ptr<PrivThread> priv_thread) -> void
{
connection.add_listener<CommandEvent>([&connection, priv_thread](CommandEvent& event)
{
if ("raw" == event.command && priv_thread->check_command(event, PrivThread::owner_priv))
{
connection.write_line(std::string{event.arg});
event.handled_ = true;
send_notice(connection, event.nick, "ack");
}
});
}
using namespace std::chrono_literals;
auto start(boost::asio::io_context & io, Settings const& settings) -> void
{
auto const connection = std::make_shared<Connection>(io);
WatchdogThread::start(*connection);
IrcParseThread::start(*connection);
RegistrationThread::start(*connection, settings.password, settings.username, settings.realname, settings.nickname);
PingThread::start(*connection);
SelfThread::start(*connection);
RegistrationThread::start(*connection, settings.password, settings.username, settings.realname, settings.nickname);
SnoteThread::start(*connection);
auto const snote_thread = SnoteThread::start(*connection);
/*
WatchdogThread::start(*connection);
IrcParseThread::start(*connection);
CommandThread::start(*connection);
auto const priv_thread = PrivThread::start(*connection, "privs.toml");
echo_thread(*connection, priv_thread);
/*
connection->add_listener<SnoteEvent>([](SnoteEvent& event) {
std::cout << "SNOTE " << static_cast<int>(event.get_tag()) << std::endl;
for (auto c : event.get_results())
*/
snote_thread->sig_snote.connect([](auto tag, auto &match) {
std::cout << "SNOTE " << static_cast<int>(tag) << std::endl;
for (auto c : match.get_results())
{
std::cout << " " << std::string_view{c.first, c.second} << std::endl;
}
});
*/
boost::asio::co_spawn(
io,

9
ping_thread.cpp
View File

@ -1,19 +1,16 @@
#include "ping_thread.hpp"
#include "connection.hpp"
#include "irc_parse_thread.hpp"
#include "ircmsg.hpp"
#include "write_irc.hpp"
auto PingThread::start(Connection& connection) -> void
{
connection.add_listener<IrcMsgEvent>([&connection](IrcMsgEvent& event)
connection.sig_ircmsg.connect([&connection](auto cmd, auto& msg)
{
auto& irc = event.irc;
if (IrcCommand::PING == event.command)
if (IrcCommand::PING == cmd)
{
send_pong(connection, irc.args[0]);
event.handled_ = true;
send_pong(connection, msg.args[0]);
}
});
}

29
registration_thread.cpp
View File

@ -1,7 +1,6 @@
#include "registration_thread.hpp"
#include "connection.hpp"
#include "irc_parse_thread.hpp"
#include "ircmsg.hpp"
#include "write_irc.hpp"
@ -17,10 +16,10 @@ RegistrationThread::RegistrationThread(
std::string nickname
)
: connection_{connection}
, password_{password}
, username_{username}
, realname_{realname}
, nickname_{nickname}
, password_{std::move(password)}
, username_{std::move(username)}
, realname_{std::move(realname)}
, nickname_{std::move(nickname)}
{
}
@ -86,7 +85,7 @@ auto RegistrationThread::on_msg_cap_ack(IrcMsg const& msg) -> void
);
if (outstanding.empty())
{
connection_.remove_listener(message_handle_);
message_handle_.disconnect();
send_cap_end(connection_);
}
}
@ -131,7 +130,7 @@ auto RegistrationThread::on_msg_cap_ls(IrcMsg const& msg) -> void
if (last)
{
connection_.remove_listener(message_handle_);
message_handle_.disconnect();
send_req();
}
}
@ -148,9 +147,9 @@ auto RegistrationThread::start(
thread->listen_for_cap_ls();
thread->connect_handle_ = connection.add_listener<ConnectEvent>([thread](ConnectEvent const&)
connection.sig_connect.connect_extended([thread](auto& handle)
{
thread->connection_.remove_listener(thread->connect_handle_);
handle.disconnect();
thread->on_connect();
});
@ -159,22 +158,22 @@ auto RegistrationThread::start(
auto RegistrationThread::listen_for_cap_ack() -> void
{
message_handle_ = connection_.add_listener<IrcMsgEvent>([thread = shared_from_this()](IrcMsgEvent const& event)
message_handle_ = connection_.sig_ircmsg.connect([thread = shared_from_this()](IrcCommand cmd, IrcMsg const& msg)
{
if (IrcCommand::CAP == event.command && event.irc.args.size() >= 2 && "*" == event.irc.args[0] && "ACK" == event.irc.args[1])
if (IrcCommand::CAP == cmd && msg.args.size() >= 2 && "*" == msg.args[0] && "ACK" == msg.args[1])
{
thread->on_msg_cap_ack(event.irc);
thread->on_msg_cap_ack(msg);
}
});
}
auto RegistrationThread::listen_for_cap_ls() -> void
{
message_handle_ = connection_.add_listener<IrcMsgEvent>([thread = shared_from_this()](IrcMsgEvent const& event)
message_handle_ = connection_.sig_ircmsg.connect([thread = shared_from_this()](IrcCommand cmd, IrcMsg const& msg)
{
if (IrcCommand::CAP == event.command && event.irc.args.size() >= 2 && "*" == event.irc.args[0] && "LS" == event.irc.args[1])
if (IrcCommand::CAP == cmd && msg.args.size() >= 2 && "*" == msg.args[0] && "LS" == msg.args[1])
{
thread->on_msg_cap_ls(event.irc);
thread->on_msg_cap_ls(msg);
}
});
}

7
registration_thread.hpp
View File

@ -1,9 +1,6 @@
#pragma once
#include <eventpp/eventdispatcher.h>
#include "connection.hpp"
#include "irc_parse_thread.hpp"
#include <memory>
#include <string>
@ -21,8 +18,8 @@ class RegistrationThread : public std::enable_shared_from_this<RegistrationThrea
std::unordered_map<std::string, std::string> caps;
std::unordered_set<std::string> outstanding;
Connection::Handle<ConnectEvent> connect_handle_;
Connection::Handle<IrcMsgEvent> message_handle_;
boost::signals2::connection connect_handle_;
boost::signals2::connection message_handle_;
auto on_connect() -> void;
auto send_req() -> void;

20
self_thread.cpp
View File

@ -1,8 +1,6 @@
#include "self_thread.hpp"
#include "connection.hpp"
#include "ircmsg.hpp"
#include "irc_parse_thread.hpp"
auto SelfThread::on_welcome(IrcMsg const& irc) -> void
{
@ -84,40 +82,40 @@ auto SelfThread::start(Connection& connection) -> std::shared_ptr<SelfThread>
{
auto thread = std::make_shared<SelfThread>(connection);
connection.add_listener<IrcMsgEvent>([thread](IrcMsgEvent& event)
connection.sig_ircmsg.connect([thread](auto cmd, auto& msg)
{
switch (event.command)
switch (cmd)
{
// Learn nickname from 001
case IrcCommand::RPL_WELCOME:
thread->on_welcome(event.irc);
thread->on_welcome(msg);
break;
// Track changes to our nickname
case IrcCommand::NICK:
thread->on_nick(event.irc);
thread->on_nick(msg);
break;
// Re-establish user modes
case IrcCommand::RPL_UMODEIS:
thread->on_umodeis(event.irc);
thread->on_umodeis(msg);
break;
case IrcCommand::JOIN:
thread->on_join(event.irc);
thread->on_join(msg);
break;
case IrcCommand::KICK:
thread->on_kick(event.irc);
thread->on_kick(msg);
break;
case IrcCommand::PART:
thread->on_part(event.irc);
thread->on_part(msg);
break;
// Interpret self mode changes
case IrcCommand::MODE:
thread->on_mode(event.irc);
thread->on_mode(msg);
break;
default: break;

19
snote_thread.cpp
View File

@ -1,7 +1,5 @@
#include "snote_thread.hpp"
#include "irc_parse_thread.hpp"
#include "ircmsg.hpp"
#include "connection.hpp"
#include "c_callback.hpp"
@ -130,12 +128,11 @@ auto SnoteThread::start(Connection& connection) -> std::shared_ptr<SnoteThread>
thread->scratch_.reset(scratch);
static char const* const prefix = "*** Notice -- ";
connection.add_listener<IrcMsgEvent>([&connection, thread](IrcMsgEvent& event)
connection.sig_ircmsg.connect([&connection, thread](auto cmd, auto& msg)
{
auto& args = event.irc.args;
if (IrcCommand::NOTICE == event.command && "*" == args[0] && args[1].starts_with(prefix))
auto& args = msg.args;
if (IrcCommand::NOTICE == cmd && "*" == args[0] && args[1].starts_with(prefix))
{
event.handled_ = true;
auto const message = args[1].substr(strlen(prefix));
unsigned match_id;
@ -163,7 +160,8 @@ auto SnoteThread::start(Connection& connection) -> std::shared_ptr<SnoteThread>
case HS_SCAN_TERMINATED:
{
auto& pattern = patterns[match_id];
connection.make_event<SnoteEvent>(pattern.tag, pattern.regex, message);
auto match = SnoteMatch{pattern.regex, message};
thread->sig_snote(pattern.tag, match);
break;
}
@ -176,12 +174,7 @@ auto SnoteThread::start(Connection& connection) -> std::shared_ptr<SnoteThread>
return thread;
}
auto SnoteEvent::get_tag() const -> SnoteTag
{
return tag_;
}
auto SnoteEvent::get_results() -> std::match_results<std::string_view::const_iterator> const&
auto SnoteMatch::get_results() -> std::match_results<std::string_view::const_iterator> const&
{
if (auto results = std::get_if<1>(&components_)) {
return *results;

12
snote_thread.hpp
View File

@ -1,6 +1,6 @@
#pragma once
#include "event.hpp"
#include <boost/signals2.hpp>
#include <memory>
#include <regex>
@ -30,15 +30,13 @@ enum class SnoteTag
SetVhostOnMarkedAccount,
};
class SnoteEvent : public Event
class SnoteMatch
{
public:
SnoteEvent(SnoteTag tag, std::regex const& regex, std::string_view full)
: tag_{tag}
, components_{std::make_pair(std::ref(regex), full)}
SnoteMatch(std::regex const& regex, std::string_view full)
: components_{std::make_pair(std::ref(regex), full)}
{}
auto get_tag() const -> SnoteTag;
auto get_results() -> std::match_results<std::string_view::const_iterator> const&;
private:
@ -64,5 +62,7 @@ struct SnoteThread
/// @brief HyperScan scratch space
std::unique_ptr<hs_scratch, ScratchDeleter> scratch_;
boost::signals2::signal<void(SnoteTag, SnoteMatch&)> sig_snote;
static auto start(Connection& connection) -> std::shared_ptr<SnoteThread>;
};

7
watchdog_thread.cpp
View File

@ -1,7 +1,6 @@
#include "watchdog_thread.hpp"
#include "connection.hpp"
#include "irc_parse_thread.hpp"
#include "write_irc.hpp"
#include <boost/asio/steady_timer.hpp>
@ -65,15 +64,15 @@ auto WatchdogThread::on_disconnect() -> void
auto WatchdogThread::start(Connection& connection) -> void
{
auto const thread = std::make_shared<WatchdogThread>(connection);
connection.add_listener<ConnectEvent>([thread](auto&)
connection.sig_connect.connect([thread]()
{
thread->on_connect();
});
connection.add_listener<DisconnectEvent>([thread](auto&)
connection.sig_disconnect.connect([thread]()
{
thread->on_disconnect();
});
connection.add_listener<IrcMsgEvent>([thread](auto&)
connection.sig_ircmsg.connect([thread](auto, auto&)
{
thread->on_activity();
});