cdb_ipc_client_generated.cpp

Go to the documentation of this file.

// AUTOGENERATED FILE - DO NOT EDIT
 
#include "barretenberg/cdb/cdb_ipc_client_generated.hpp"
#include "barretenberg/cdb/cdb_execute.hpp"
#include "barretenberg/serialize/msgpack.hpp"
#include "barretenberg/serialize/msgpack_impl.hpp"
 
#include <stdexcept>
#include <tuple>
 
namespace bb::cdb {
 
CdbIpcClient::CdbIpcClient(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);
    }
}
 
CdbIpcClient::~CdbIpcClient()
{
    if (client_) {
        client_->close();
    }
}
 
template <typename Cmd> typename Cmd::Response CdbIpcClient::send(Cmd&& cmd) const
{
    // Wrap command in CdbCommand NamedUnion, then in a 1-element tuple (matches server expectations)
    CdbCommand 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();
 
    CdbCommandResponse 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, CdbErrorResponse>) {
            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");
        }
    });
}
 
CdbGetContractInstance::Response CdbIpcClient::get_contract_instance(CdbGetContractInstance cmd) const
{
    return send(std::move(cmd));
}
 
CdbGetContractClass::Response CdbIpcClient::get_contract_class(CdbGetContractClass cmd) const
{
    return send(std::move(cmd));
}
 
CdbGetBytecodeCommitment::Response CdbIpcClient::get_bytecode_commitment(CdbGetBytecodeCommitment cmd)
{
    return send(std::move(cmd));
}
 
CdbGetDebugFunctionName::Response CdbIpcClient::get_debug_function_name(CdbGetDebugFunctionName cmd) const
{
    return send(std::move(cmd));
}
 
void CdbIpcClient::add_contracts(CdbAddContracts cmd)
{
    send(std::move(cmd));
}
 
void CdbIpcClient::create_checkpoint(CdbCreateCheckpoint cmd)
{
    send(std::move(cmd));
}
 
void CdbIpcClient::commit_checkpoint(CdbCommitCheckpoint cmd)
{
    send(std::move(cmd));
}
 
void CdbIpcClient::revert_checkpoint(CdbRevertCheckpoint cmd)
{
    send(std::move(cmd));
}
 
void CdbIpcClient::add_contract_class(CdbAddContractClass cmd)
{
    send(std::move(cmd));
}
 
void CdbIpcClient::add_contract_instance(CdbAddContractInstance cmd)
{
    send(std::move(cmd));
}
 
void CdbIpcClient::register_function_signatures(CdbRegisterFunctionSignatures cmd)
{
    send(std::move(cmd));
}
 
CdbGetContractClassIds::Response CdbIpcClient::get_contract_class_ids() const
{
    return send(CdbGetContractClassIds{});
}
 
void CdbIpcClient::shutdown()
{
    send(CdbShutdown{});
}
 
} // namespace bb::cdb