56 std::shared_ptr<crypto::Certificate> serverCA, crypto::Identity clientIdentity,
57 std::function<
void()> loopSignal,
const std::string& serverHost,
58 const std::string& pushClientId =
"", std::shared_ptr<Logger> logger = {});
62 virtual void setPushNotificationToken(
const std::string& token)
override {
63#ifdef OPENDHT_PUSH_NOTIFICATIONS
70 virtual void setPushNotificationTopic(
const std::string& topic)
override {
71#ifdef OPENDHT_PUSH_NOTIFICATIONS
72 notificationTopic_ = topic;
78 virtual void setPushNotificationPlatform(
const std::string& platform)
override {
79#ifdef OPENDHT_PUSH_NOTIFICATIONS
92 void setOnPublicAddressChanged(PublicAddressChangedCb cb)
override {
93 publicAddressChangedCb_ = std::move(cb);
101 return std::max(getStatus(AF_INET), getStatus(AF_INET6));
128 virtual void get(
const InfoHash& key, GetCallback cb, DoneCallbackSimple donecb={}, Value::Filter&& f={}, Where&& w = {})
override {
129 get(key, cb, bindDoneCb(std::move(donecb)), std::forward<Value::Filter>(f), std::forward<Where>(w));
131 virtual void get(
const InfoHash& key, GetCallbackSimple cb, DoneCallback donecb={}, Value::Filter&& f={}, Where&& w = {})
override {
132 get(key, bindGetCb(cb), std::move(donecb), std::forward<Value::Filter>(f), std::forward<Where>(w));
134 virtual void get(
const InfoHash& key, GetCallbackSimple cb, DoneCallbackSimple donecb, Value::Filter&& f={}, Where&& w = {})
override {
135 get(key, bindGetCb(cb), bindDoneCb(std::move(donecb)), std::forward<Value::Filter>(f), std::forward<Where>(w));
147 DoneCallback cb=
nullptr,
148 time_point created=time_point::max(),
149 bool permanent =
false)
override;
152 DoneCallbackSimple cb,
153 time_point created=time_point::max(),
154 bool permanent =
false)
override
156 put(key, v, bindDoneCb(std::move(cb)), created, permanent);
161 DoneCallback cb=
nullptr,
162 time_point created=time_point::max(),
163 bool permanent =
false)
override
165 put(key, std::make_shared<Value>(std::move(v)), std::move(cb), created, permanent);
167 void put(
const InfoHash& key,
169 DoneCallbackSimple cb,
170 time_point created=time_point::max(),
171 bool permanent =
false)
override
173 put(key, std::forward<Value>(v), bindDoneCb(std::move(cb)), created, permanent);
198 return listen(key, [cb=std::move(cb)](
const std::vector<Sp<Value>>& vals,
bool expired){
202 }, std::forward<Value::Filter>(f), std::forward<Where>(w));
204 virtual size_t listen(
const InfoHash& key, GetCallbackSimple cb, Value::Filter f={}, Where w={})
override {
205 return listen(key, bindGetCb(std::move(cb)), std::forward<Value::Filter>(f), std::forward<Where>(w));
211 virtual bool cancelListen(
const InfoHash& key,
size_t token)
override;
219 time_point periodic(
const uint8_t*,
size_t,
SockAddr,
const time_point& now)
override;
220 time_point periodic(
const uint8_t* buf,
size_t buflen,
const sockaddr* from, socklen_t fromlen,
const time_point& now)
override {
221 return periodic(buf, buflen,
SockAddr(from, fromlen), now);
235 virtual void query(
const InfoHash& key, QueryCallback cb, DoneCallbackSimple done_cb = {}, Query&& q = {})
override {
236 query(key, cb, bindDoneCb(std::move(done_cb)), std::forward<Query>(q));
255 void pingNode(
SockAddr, DoneCallbackSimple&& ={})
override { }
257 virtual void registerType(
const ValueType& type)
override {
258 types.registerType(type);
260 const ValueType& getType(ValueType::Id type_id)
const override {
261 return types.getType(type_id);
272 void insertNode(
const NodeExport&)
override { }
274 std::vector<NodeExport>
exportNodes()
const override {
return {}; }
275 std::vector<ValuesExport> exportValues()
const override {
return {}; }
276 void importValues(
const std::vector<ValuesExport>&)
override {}
277 std::string getStorageLog()
const override {
return {}; }
278 std::string getStorageLog(
const InfoHash&)
const override {
return {}; }
279 std::string getRoutingTablesLog(sa_family_t)
const override {
return {}; }
280 std::string getSearchesLog(sa_family_t)
const override {
return {}; }
281 std::string getSearchLog(
const InfoHash&, sa_family_t)
const override {
return {}; }
282 void dumpTables()
const override {}
283 std::vector<unsigned> getNodeMessageStats(
bool)
override {
return {}; }
285 virtual size_t getStorageLimit()
const override {
return 0; }
289 void connectivityChanged()
override {
294 void listenKeepIdle(uint32_t seconds) {
295 listenKeepIdle_ = seconds;
297 inline uint32_t listenKeepIdle() {
return listenKeepIdle_; }
311 void getProxyInfos();
312 void queryProxyInfo(
const std::shared_ptr<InfoState>& infoState,
const std::shared_ptr<http::Resolver>& resolver, sa_family_t family);
313 void onProxyInfos(
const Json::Value& val,
const sa_family_t family);
314 SockAddr parsePublicAddress(
const Json::Value& val);
318 void handleExpireListener(
const asio::error_code &ec,
const InfoHash& key);
321 struct OperationState;
322 enum class ListenMethod {
327 using CacheValueCallback = std::function<bool(
const std::vector<std::shared_ptr<Value>>& values,
bool expired, system_clock::time_point)>;
332 void sendListen(
const restinio::http_request_header_t& header,
const CacheValueCallback& cb,
333 const Sp<OperationState>& opstate, Listener& listener, ListenMethod method = ListenMethod::LISTEN);
334 void handleResubscribe(
const asio::error_code& ec,
const InfoHash& key,
335 const size_t token, std::shared_ptr<OperationState> opstate);
337 void doPut(
const InfoHash&, Sp<Value>, DoneCallbackSimple, time_point created,
bool permanent);
338 void handleRefreshPut(
const asio::error_code& ec, InfoHash key, Value::Id
id);
343 void getConnectivityStatus();
347 void cancelAllListeners();
349 std::atomic_bool isDestroying_ {
false};
351 std::string proxyUrl_;
352 dht::crypto::Identity clientIdentity_;
353 std::shared_ptr<dht::crypto::Certificate> serverCertificate_;
355 std::string pushClientId_;
356 std::string pushSessionId_;
358 mutable std::mutex lockCurrentProxyInfos_;
359 NodeStatus statusIpv4_ {NodeStatus::Disconnected};
360 NodeStatus statusIpv6_ {NodeStatus::Disconnected};
361 NodeStats stats4_ {};
362 NodeStats stats6_ {};
363 SockAddr localAddrv4_;
364 SockAddr localAddrv6_;
365 SockAddr publicAddressV4_;
366 SockAddr publicAddressV6_;
367 std::atomic_bool launchConnectedCbs_ {
false};
368 PublicAddressChangedCb publicAddressChangedCb_ {};
379 asio::io_context httpContext_;
380 mutable std::mutex resolverLock_;
381 std::shared_ptr<http::Resolver> resolver_;
383 mutable std::mutex requestLock_;
384 std::map<unsigned, std::shared_ptr<http::Request>> requests_;
388 std::thread httpClientThread_;
395 mutable std::mutex searchLock_;
396 size_t listenerToken_ {0};
397 std::map<InfoHash, ProxySearch> searches_;
402 uint32_t listenKeepIdle_ {120};
407 std::mutex lockCallbacks_;
408 std::vector<std::function<void()>> callbacks_;
410 Sp<InfoState> infoState_;
415 void handleProxyConfirm(
const asio::error_code &ec);
416 std::unique_ptr<asio::steady_timer> nextProxyConfirmationTimer_;
417 std::unique_ptr<asio::steady_timer> listenerRestartTimer_;
422 void restartListeners(
const asio::error_code &ec);
428 void resubscribe(
const InfoHash& key,
const size_t token, Listener& listener);
434 std::string deviceKey_ {};
439 std::string notificationTopic_ {};
444 std::string platform_
455 const std::function<void()> loopSignal_;
457#ifdef OPENDHT_PUSH_NOTIFICATIONS
458 std::string fillBody(
bool resubscribe);
459 void getPushRequest(Json::Value&)
const;
462 Json::StreamWriterBuilder jsonBuilder_;
463 std::unique_ptr<Json::CharReader> jsonReader_;
465 std::shared_ptr<http::Request> buildRequest(
const std::string& target = {});