mirror of
https://github.com/hanzo-ds/cpp.git
synced 2026-10-30 20:31:26 +00:00
zeekay
286f257aae
Pure rename applied on top of upstream tag v2.6.2 (8d2415d6), not HEAD.
The fork was cut at 737145d = v2.6.2-57, which still declared version 2.6.2
in version.h; renaming there would have shipped 57 unreleased commits wearing
a 2.6.2 label. Reset to the tag first so this commit changes names only.
clickhouse/ -> datastore/ (public include root)
namespace clickhouse -> namespace datastore
CLICKHOUSE_CPP_VERSION -> DATASTORE_CPP_VERSION
clickhouse-cpp-lib/-ut -> datastore-cpp-lib/-ut (CMake, Bazel)
CH_MAP_BOOL_TO_UINT8 -> DS_MAP_BOOL_TO_UINT8
CLICKHOUSE_* -> DATASTORE_* (test env vars)
doc links -> docs.hanzo.ai/datastore
This client speaks the NATIVE binary protocol only - there is no HTTP path
and no X-ClickHouse-* header anywhere in it, so the header rename that the
HTTP clients required does not apply and nothing here was broken.
The one string that reaches the wire is CLIENT_NAME, sent by both SendHello
and SendQuery's ClientInfo from a single macro, and it lands in
system.query_log.client_name. Both sites still read the one macro, so they
stay consistent and the server's Hello/Query consistency check is satisfied.
Old rows keep the old name; that is a reporting discontinuity, not a
migration, since nothing keys on it.
CI is repointed at our own server: ghcr.io/hanzoai/datastore:26.2.3.2, the
image production runs. Its entrypoint honours DATASTORE_SKIP_USER_SETUP, not
the CLICKHOUSE_ spelling the compose file used, and its config lives in
/etc/hanzo-datastore-server. ci/docker-compose/config.xml is now layered in
as a config.d drop-in so the image keeps its own white-labelling. That file
and users.xml deliberately keep a <clickhouse> root: it must match the roots
of the drop-ins the image ships, and a mismatch fails silently - the server
logs "Merging bypassed" and starts with every drop-in discarded.
The remote-TLS suites used to default to the third-party host
play.clickhouse.com. They now read DATASTORE_SECURE*_HOST and skip when it is
unset rather than point at a host we do not run.
Dropped as upstream infrastructure with no meaning here: AI_POLICY.md
(upstream's policy about their codebase), .travis.yml (dead CI referencing a
third-party apt repo), cross-repo-bug-relay.yml (relays our issues into an
upstream triage repo). LICENSE keeps its copyright notice, as Apache-2.0
requires.
Verified: cmake configure + 115-target build clean; the full suite is green
against ghcr.io/hanzoai/datastore:26.2.3.2 (894 passed, 0 failed); the
pristine v2.6.2 build run against that same server passes the identical set,
and both logged the same 3914 queries under their respective client names.
132 lines
3.4 KiB
C++
132 lines
3.4 KiB
C++
#include "tcp_server.h"
|
|
|
|
#include <datastore/base/socket.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <iostream>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <thread>
|
|
|
|
// for EAI_* error codes
|
|
#if defined(_win_)
|
|
# include <ws2tcpip.h>
|
|
#else
|
|
# include <netdb.h>
|
|
#endif
|
|
|
|
using namespace datastore;
|
|
|
|
TEST(Socketcase, connecterror) {
|
|
int port = 19978;
|
|
NetworkAddress addr("localhost", std::to_string(port));
|
|
LocalTcpServer server(port);
|
|
server.start();
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
try {
|
|
Socket socket(addr);
|
|
} catch (const std::system_error& e) {
|
|
FAIL();
|
|
}
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
server.stop();
|
|
try {
|
|
Socket socket(addr);
|
|
FAIL();
|
|
} catch (const std::system_error& e) {
|
|
ASSERT_NE(EINPROGRESS,e.code().value());
|
|
}
|
|
}
|
|
|
|
TEST(Socketcase, timeoutrecv) {
|
|
using Seconds = std::chrono::seconds;
|
|
|
|
int port = 19979;
|
|
NetworkAddress addr("localhost", std::to_string(port));
|
|
LocalTcpServer server(port);
|
|
server.start();
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
try {
|
|
Socket socket(addr, SocketTimeoutParams { Seconds(5), Seconds(5), Seconds(5) });
|
|
|
|
std::unique_ptr<InputStream> ptr_input_stream = socket.makeInputStream();
|
|
char buf[1024];
|
|
ptr_input_stream->Read(buf, sizeof(buf));
|
|
|
|
}
|
|
catch (const std::system_error& e) {
|
|
#if defined(_unix_)
|
|
auto expected = EAGAIN;
|
|
#else
|
|
auto expected = WSAETIMEDOUT;
|
|
#endif
|
|
ASSERT_EQ(expected, e.code().value());
|
|
}
|
|
|
|
std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
server.stop();
|
|
}
|
|
|
|
TEST(Socketcase, gaierror) {
|
|
try {
|
|
NetworkAddress addr("host.invalid", "80"); // never resolves
|
|
FAIL();
|
|
} catch (const std::system_error& e) {
|
|
ASSERT_PRED1([](int error) { return error == EAI_NONAME || error == EAI_AGAIN || error == EAI_FAIL; }, e.code().value());
|
|
}
|
|
}
|
|
|
|
TEST(Socketcase, connecttimeout) {
|
|
using Clock = std::chrono::steady_clock;
|
|
|
|
try {
|
|
NetworkAddress("::1", "19980");
|
|
} catch (const std::system_error& e) {
|
|
GTEST_SKIP() << "missing IPv6 support";
|
|
}
|
|
|
|
NetworkAddress addr("100::1", "19980"); // "discard" IPv6 address
|
|
|
|
const auto connect_start = Clock::now();
|
|
try {
|
|
Socket socket(addr, SocketTimeoutParams{std::chrono::milliseconds(100)});
|
|
FAIL();
|
|
} catch (const std::system_error& e) {
|
|
const int error = e.code().value();
|
|
if (error == ENETUNREACH || error == EHOSTUNREACH
|
|
#if defined(_win_)
|
|
|| error == WSAENETUNREACH
|
|
#endif
|
|
) {
|
|
GTEST_SKIP() << "missing IPv6 support";
|
|
}
|
|
#if defined(_win_)
|
|
const auto expected = WSAETIMEDOUT;
|
|
#else
|
|
const auto expected = ETIMEDOUT;
|
|
#endif
|
|
EXPECT_EQ(expected, error);
|
|
EXPECT_LT(Clock::now() - connect_start, std::chrono::seconds(5));
|
|
}
|
|
}
|
|
|
|
// Test to verify that reading from empty socket doesn't hangs.
|
|
//TEST(Socketcase, ReadFromEmptySocket) {
|
|
// const int port = 12345;
|
|
// const NetworkAddress addr("127.0.0.1", std::to_string(port));
|
|
|
|
// LocalTcpServer server(port);
|
|
// server.start();
|
|
|
|
// std::this_thread::sleep_for(std::chrono::seconds(1));
|
|
|
|
// char buffer[1024];
|
|
// Socket socket(addr);
|
|
// socket.SetTcpNoDelay(true);
|
|
// auto input = socket.makeInputStream();
|
|
// input->Read(buffer, sizeof(buffer));
|
|
//}
|