XmlRpcServer.cpp

Go to the documentation of this file.

#include <cassert>
#include <thread>
#include <vector>
 
#include <xmlrpc-c/registry.hpp>
#include <xmlrpc-c/server_abyss.hpp>
 
#include "XmlRpcServer.hpp"
 
namespace
{
class RpcMethodHdlSs : public xmlrpc_c::method
{
public:
    explicit RpcMethodHdlSs(std::function<std::optional<std::string>(const std::string&)>& handler)
        : handler(handler)
    {
        _signature = "s:s";
    }
 
    void execute(const xmlrpc_c::paramList& params, xmlrpc_c::value* const retval) override
    {
        // We have one parameter in our RPC method signature
        assert(params.size() == 1);
        const std::string arg{params.getString(0)};
 
        const std::optional<std::string> res = handler(arg);
 
        if (res.has_value()) {
            *retval = xmlrpc_c::value_string(res.value());
        } else {
            *retval = xmlrpc_c::value_nil();
        }
    }
 
private:
    std::function<std::optional<std::string>(const std::string&)> handler;
};
} // namespace
 
namespace aai
{
struct XmlRpcServerPrivate
{
    explicit XmlRpcServerPrivate(uint16_t listen_port)
        : rpc_server(xmlrpc_c::serverAbyss::constrOpt()
                       .registryP(&rpc_registry)
                       .portNumber(listen_port)
                       .serverOwnsSignals(false))
    {}
    XmlRpcServerPrivate(const struct sockaddr* sa, socklen_t sa_len)
        : rpc_server(xmlrpc_c::serverAbyss::constrOpt()
                       .registryP(&rpc_registry)
                       .sockAddrP(sa)
                       .sockAddrLen(sa_len))
    {}
    XmlRpcServerPrivate(const XmlRpcServerPrivate&) = delete;
    ~XmlRpcServerPrivate()
    {
        if (rpc_server_thread && rpc_server_thread->joinable()) {
            rpc_server_thread->join();
        }
    }
 
    xmlrpc_c::registry rpc_registry{};
    xmlrpc_c::serverAbyss rpc_server;
    std::unique_ptr<std::thread> rpc_server_thread{nullptr};
    bool has_started{false};
};
 
XmlRpcServer::XmlRpcServer(uint16_t listen_port)
    : priv(std::make_unique<XmlRpcServerPrivate>(listen_port))
{}
 
XmlRpcServer::XmlRpcServer(const struct sockaddr* sa, socklen_t sa_len)
    : priv(std::make_unique<XmlRpcServerPrivate>(sa, sa_len))
{}
 
XmlRpcServer::~XmlRpcServer()
{
    stop();
    priv.reset(nullptr);
}
 
void XmlRpcServer::start()
{
    if (priv->has_started) {
        return;
    }
 
    assert(!priv->rpc_server_thread);
    priv->rpc_server_thread = std::make_unique<std::thread>([this]() { priv->rpc_server.run(); });
    priv->has_started = true;
}
 
void XmlRpcServer::stop()
{
    if (!priv->has_started || !priv->rpc_server_thread) {
        return;
    }
 
    priv->rpc_server.terminate();
}
 
void XmlRpcServer::register_method_handler(
  std::string_view name,
  std::function<std::optional<std::string>(const std::string&)>
    handler)
{
    priv->rpc_registry.addMethod(std::string{name},
                                 static_cast<xmlrpc_c::method*>(new RpcMethodHdlSs{handler}));
}
} // namespace aai