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.
178 lines
4.0 KiB
C++
178 lines
4.0 KiB
C++
#pragma once
|
|
|
|
#include "platform.h"
|
|
#include "input.h"
|
|
#include "output.h"
|
|
#include "endpoints_iterator.h"
|
|
|
|
#include <cstddef>
|
|
#include <string>
|
|
#include <chrono>
|
|
|
|
#if defined(_win_)
|
|
# include <winsock2.h>
|
|
# include <ws2tcpip.h>
|
|
#else
|
|
# include <arpa/inet.h>
|
|
# include <sys/types.h>
|
|
# include <sys/socket.h>
|
|
# include <poll.h>
|
|
|
|
# if !defined(SOCKET)
|
|
# define SOCKET int
|
|
# endif
|
|
#endif
|
|
|
|
#include <memory>
|
|
#include <system_error>
|
|
|
|
struct addrinfo;
|
|
|
|
namespace datastore {
|
|
|
|
struct ClientOptions;
|
|
|
|
/** Address of a host to establish connection to.
|
|
*
|
|
*/
|
|
class NetworkAddress {
|
|
public:
|
|
explicit NetworkAddress(const std::string& host,
|
|
const std::string& port = "0");
|
|
~NetworkAddress();
|
|
|
|
const struct addrinfo* Info() const;
|
|
const std::string & Host() const;
|
|
|
|
private:
|
|
const std::string host_;
|
|
struct addrinfo* info_;
|
|
};
|
|
|
|
#if defined(_win_)
|
|
|
|
class windowsErrorCategory : public std::error_category {
|
|
public:
|
|
char const* name() const noexcept override final;
|
|
std::string message(int c) const override final;
|
|
|
|
static windowsErrorCategory const& category();
|
|
};
|
|
|
|
#endif
|
|
|
|
#if defined(_unix_)
|
|
|
|
class getaddrinfoErrorCategory : public std::error_category {
|
|
public:
|
|
char const* name() const noexcept override final;
|
|
std::string message(int c) const override final;
|
|
|
|
static getaddrinfoErrorCategory const& category();
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
class SocketBase {
|
|
public:
|
|
virtual ~SocketBase();
|
|
|
|
virtual std::unique_ptr<InputStream> makeInputStream() const = 0;
|
|
virtual std::unique_ptr<OutputStream> makeOutputStream() const = 0;
|
|
};
|
|
|
|
|
|
class SocketFactory {
|
|
public:
|
|
virtual ~SocketFactory();
|
|
|
|
// TODO: move connection-related options to ConnectionOptions structure.
|
|
|
|
virtual std::unique_ptr<SocketBase> connect(const ClientOptions& opts, const Endpoint& endpoint) = 0;
|
|
|
|
virtual void sleepFor(const std::chrono::milliseconds& duration);
|
|
};
|
|
|
|
|
|
struct SocketTimeoutParams {
|
|
std::chrono::milliseconds connect_timeout{ 5000 };
|
|
std::chrono::milliseconds recv_timeout{ 0 };
|
|
std::chrono::milliseconds send_timeout{ 0 };
|
|
};
|
|
|
|
class Socket : public SocketBase {
|
|
public:
|
|
Socket(const NetworkAddress& addr, const SocketTimeoutParams& timeout_params);
|
|
Socket(const NetworkAddress& addr);
|
|
Socket(Socket&& other) noexcept;
|
|
Socket& operator=(Socket&& other) noexcept;
|
|
|
|
~Socket() override;
|
|
|
|
/// @params idle the time (in seconds) the connection needs to remain
|
|
/// idle before TCP starts sending keepalive probes.
|
|
/// @params intvl the time (in seconds) between individual keepalive probes.
|
|
/// @params cnt the maximum number of keepalive probes TCP should send
|
|
/// before dropping the connection.
|
|
void SetTcpKeepAlive(int idle, int intvl, int cnt) noexcept;
|
|
|
|
/// @params nodelay whether to enable TCP_NODELAY
|
|
void SetTcpNoDelay(bool nodelay) noexcept;
|
|
|
|
std::unique_ptr<InputStream> makeInputStream() const override;
|
|
std::unique_ptr<OutputStream> makeOutputStream() const override;
|
|
|
|
protected:
|
|
Socket(const Socket&) = delete;
|
|
Socket& operator = (const Socket&) = delete;
|
|
void Close();
|
|
|
|
SOCKET handle_;
|
|
};
|
|
|
|
|
|
class NonSecureSocketFactory : public SocketFactory {
|
|
public:
|
|
~NonSecureSocketFactory() override;
|
|
|
|
std::unique_ptr<SocketBase> connect(const ClientOptions& opts, const Endpoint& endpoint) override;
|
|
|
|
protected:
|
|
virtual std::unique_ptr<Socket> doConnect(const NetworkAddress& address, const ClientOptions& opts);
|
|
|
|
void setSocketOptions(Socket& socket, const ClientOptions& opts);
|
|
};
|
|
|
|
|
|
class SocketInput : public InputStream {
|
|
public:
|
|
explicit SocketInput(SOCKET s);
|
|
~SocketInput();
|
|
|
|
protected:
|
|
bool Skip(size_t bytes) override;
|
|
size_t DoRead(void* buf, size_t len) override;
|
|
|
|
private:
|
|
SOCKET s_;
|
|
};
|
|
|
|
class SocketOutput : public OutputStream {
|
|
public:
|
|
explicit SocketOutput(SOCKET s);
|
|
~SocketOutput();
|
|
|
|
protected:
|
|
size_t DoWrite(const void* data, size_t len) override;
|
|
|
|
private:
|
|
SOCKET s_;
|
|
};
|
|
|
|
static struct NetrworkInitializer {
|
|
NetrworkInitializer();
|
|
} gNetrworkInitializer;
|
|
|
|
}
|