wsdb_ipc_client_generated.cpp

Go to the documentation of this file.

// AUTOGENERATED FILE - DO NOT EDIT
 
#include "barretenberg/wsdb/wsdb_ipc_client_generated.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include "barretenberg/serialize/msgpack_impl.hpp"
#include "barretenberg/wsdb/wsdb_execute.hpp"
 
#include <stdexcept>
#include <tuple>
 
namespace bb::wsdb {
 
WsdbIpcClient::WsdbIpcClient(const std::string& socket_path)
    : client_(ipc::IpcClient::create_socket(socket_path))
{
    if (!client_->connect()) {
        throw std::runtime_error("Failed to connect to server at " + socket_path);
    }
}
 
WsdbIpcClient::~WsdbIpcClient()
{
    if (client_) {
        client_->close();
    }
}
 
template <typename Cmd> typename Cmd::Response WsdbIpcClient::send(Cmd&& cmd) const
{
    // Wrap command in WsdbCommand NamedUnion, then in a 1-element tuple (matches server expectations)
    WsdbCommand command = std::forward<Cmd>(cmd);
    auto wrapped = std::make_tuple(std::move(command));
 
    // Serialize to msgpack
    msgpack::sbuffer send_buffer;
    msgpack::pack(send_buffer, wrapped);
 
    // Send to server
    constexpr uint64_t timeout_ns = 30'000'000'000ULL; // 30 seconds
    if (!client_->send(send_buffer.data(), send_buffer.size(), timeout_ns)) {
        throw std::runtime_error("Failed to send command to server");
    }
 
    // Receive response
    auto response_span = client_->receive(timeout_ns);
    if (response_span.empty()) {
        throw std::runtime_error("Empty response from server");
    }
 
    // Deserialize response
    auto unpacked = msgpack::unpack(reinterpret_cast<const char*>(response_span.data()), response_span.size());
    auto response_obj = unpacked.get();
 
    WsdbCommandResponse response;
    response_obj.convert(response);
 
    // Release the receive buffer
    client_->release(response_span.size());
 
    // Check for error response
    return std::move(response).visit([](auto&& resp) -> typename Cmd::Response {
        using RespType = std::decay_t<decltype(resp)>;
 
        if constexpr (std::is_same_v<RespType, WsdbErrorResponse>) {
            throw std::runtime_error("Server error: " + resp.message);
        } else if constexpr (std::is_same_v<RespType, typename Cmd::Response>) {
            return std::forward<decltype(resp)>(resp);
        } else {
            throw std::runtime_error("Unexpected response type from server");
        }
    });
}
 
WsdbGetTreeInfo::Response WsdbIpcClient::get_tree_info(WsdbGetTreeInfo cmd) const
{
    return send(std::move(cmd));
}
 
WsdbGetStateReference::Response WsdbIpcClient::get_state_reference(WsdbGetStateReference cmd) const
{
    return send(std::move(cmd));
}
 
WsdbGetInitialStateReference::Response WsdbIpcClient::get_initial_state_reference() const
{
    return send(WsdbGetInitialStateReference{});
}
 
WsdbGetLeafValue::Response WsdbIpcClient::get_leaf_value(WsdbGetLeafValue cmd) const
{
    return send(std::move(cmd));
}
 
WsdbGetLeafPreimage::Response WsdbIpcClient::get_leaf_preimage(WsdbGetLeafPreimage cmd) const
{
    return send(std::move(cmd));
}
 
WsdbGetSiblingPath::Response WsdbIpcClient::get_sibling_path(WsdbGetSiblingPath cmd) const
{
    return send(std::move(cmd));
}
 
WsdbGetBlockNumbersForLeafIndices::Response WsdbIpcClient::get_block_numbers_for_leaf_indices(
    WsdbGetBlockNumbersForLeafIndices cmd) const
{
    return send(std::move(cmd));
}
 
WsdbFindLeafIndices::Response WsdbIpcClient::find_leaf_indices(WsdbFindLeafIndices cmd) const
{
    return send(std::move(cmd));
}
 
WsdbFindLowLeaf::Response WsdbIpcClient::find_low_leaf(WsdbFindLowLeaf cmd) const
{
    return send(std::move(cmd));
}
 
WsdbFindSiblingPaths::Response WsdbIpcClient::find_sibling_paths(WsdbFindSiblingPaths cmd) const
{
    return send(std::move(cmd));
}
 
void WsdbIpcClient::append_leaves(WsdbAppendLeaves cmd) const
{
    send(std::move(cmd));
}
 
WsdbBatchInsert::Response WsdbIpcClient::batch_insert(WsdbBatchInsert cmd) const
{
    return send(std::move(cmd));
}
 
WsdbSequentialInsert::Response WsdbIpcClient::sequential_insert(WsdbSequentialInsert cmd) const
{
    return send(std::move(cmd));
}
 
void WsdbIpcClient::update_archive(WsdbUpdateArchive cmd) const
{
    send(std::move(cmd));
}
 
WsdbCommit::Response WsdbIpcClient::commit()
{
    return send(WsdbCommit{});
}
 
void WsdbIpcClient::rollback()
{
    send(WsdbRollback{});
}
 
WsdbSyncBlock::Response WsdbIpcClient::sync_block(WsdbSyncBlock cmd)
{
    return send(std::move(cmd));
}
 
WsdbCreateFork::Response WsdbIpcClient::create_fork(WsdbCreateFork cmd)
{
    return send(std::move(cmd));
}
 
void WsdbIpcClient::delete_fork(WsdbDeleteFork cmd)
{
    send(std::move(cmd));
}
 
WsdbFinalizeBlocks::Response WsdbIpcClient::finalize_blocks(WsdbFinalizeBlocks cmd) const
{
    return send(std::move(cmd));
}
 
WsdbUnwindBlocks::Response WsdbIpcClient::unwind_blocks(WsdbUnwindBlocks cmd)
{
    return send(std::move(cmd));
}
 
WsdbRemoveHistoricalBlocks::Response WsdbIpcClient::remove_historical_blocks(WsdbRemoveHistoricalBlocks cmd) const
{
    return send(std::move(cmd));
}
 
WsdbGetStatus::Response WsdbIpcClient::get_status() const
{
    return send(WsdbGetStatus{});
}
 
void WsdbIpcClient::create_checkpoint(WsdbCreateCheckpoint cmd)
{
    send(std::move(cmd));
}
 
void WsdbIpcClient::commit_checkpoint(WsdbCommitCheckpoint cmd)
{
    send(std::move(cmd));
}
 
void WsdbIpcClient::revert_checkpoint(WsdbRevertCheckpoint cmd)
{
    send(std::move(cmd));
}
 
void WsdbIpcClient::commit_all_checkpoints(WsdbCommitAllCheckpoints cmd)
{
    send(std::move(cmd));
}
 
void WsdbIpcClient::revert_all_checkpoints(WsdbRevertAllCheckpoints cmd)
{
    send(std::move(cmd));
}
 
void WsdbIpcClient::copy_stores(WsdbCopyStores cmd) const
{
    send(std::move(cmd));
}
 
void WsdbIpcClient::shutdown()
{
    send(WsdbShutdown{});
}
 
} // namespace bb::wsdb