Method buzzHouse

programs/client/FuzzLoop.cpp:587–1186

Returns false when server is not available.

/// Returns false when server is not available.
bool Client::buzzHouse()
{
    String full_query;
    bool no_eof = true;
    bool server_up = true;
    bool no_timeout = true;
    static const String & rerun_database = "--External database ";
    static const RE2 rerun_database_re(R"((?i)^--External\s+database\s+(.*)$)");
    static const String & rerun_table = "--External table ";
    static const RE2 rerun_table_re(R"((?i)^--External\s+table\s+(.*)$)");
    static const RE2 extern_re(
        R"((?i)^--External\s+command\s+(?:(async)\s+)?with\s+seed\s+(\d+)\s+to\s+([^\s]+)\s+table\s+([0-9A-Fa-f]+)\s+([0-9A-Fa-f]+)\s*$)");

    /// Set time to run, but what if a query runs for too long?
    using clock = std::chrono::steady_clock;
    const auto deadline = fuzz_config->time_to_run > 0
        ? std::optional<clock::time_point>(clock::now() + std::chrono::minutes(fuzz_config->time_to_run))
        : std::nullopt;
    full_query.reserve(8192);
    if (fuzz_config->read_log)
    {
        std::ifstream infile(fuzz_config->log_path);

        while (server_up && (no_timeout = (!deadline || clock::now() < *deadline))
               && (no_eof = static_cast<bool>(std::getline(infile, full_query))))
        {
            String async_flag;
            String seed_str;
            String engine;
            String database;
            String table;

            if (full_query == restart_cmd)
            {
                server_up &= fuzzLoopReconnect();
            }
            else if (startsWith(full_query, rerun_database) && RE2::FullMatch(full_query, rerun_database_re, &database))
            {
                const auto x = external_integrations->reRunCreateDatabase(BuzzHouse::IntegrationCall::Dolor, database);

                UNUSED(x);
            }
            else if (startsWith(full_query, rerun_table) && RE2::FullMatch(full_query, rerun_table_re, &table))
            {
                const auto x = external_integrations->reRunCreateTable(BuzzHouse::IntegrationCall::Dolor, table);

                UNUSED(x);
            }
            else if (
                startsWith(full_query, external_cmd)
                && RE2::FullMatch(full_query, extern_re, &async_flag, &seed_str, &engine, &database, &table))
            {
                uint64_t seed = 0;
                const auto * const first = seed_str.data();
                const auto * const last = first + seed_str.size();
                const auto x = std::from_chars(first, last, seed, 10);

                if (x.ec != std::errc{} || x.ptr != last)