dht_interface.h

// Copyright (c) 2014-2026 Savoir-faire Linux Inc.
// SPDX-License-Identifier: MIT
#pragma once
 
#include "infohash.h"
#include "logger.h"
#include "node_export.h"
 
#include <queue>
 
namespace dht {
 
namespace net {
class DatagramSocket;
}
 
class OPENDHT_PUBLIC DhtInterface
{
public:
    DhtInterface() = default;
    DhtInterface(const std::shared_ptr<Logger>& l)
        : logger_(l)
    {}
    virtual ~DhtInterface() = default;
 
    // [[deprecated]]
    using Status = NodeStatus;
    // [[deprecated]]
    using NodeExport = dht::NodeExport;

    virtual NodeStatus updateStatus(sa_family_t af) { return getStatus(af); }
    virtual NodeStatus getStatus(sa_family_t af) const = 0;
    virtual NodeStatus getStatus() const = 0;
 
    void addOnConnectedCallback(std::function<void()> cb) { onConnectCallbacks_.emplace(std::move(cb)); }
    virtual void setOnPublicAddressChanged(PublicAddressChangedCb) {}
 
    virtual net::DatagramSocket* getSocket() const { return {}; }

    virtual const InfoHash& getNodeId() const = 0;

    virtual void shutdown(ShutdownCallback cb, bool stop = false) = 0;

    virtual bool isRunning(sa_family_t af = 0) const = 0;
 
    virtual void registerType(const ValueType& type) = 0;
 
    virtual const ValueType& getType(ValueType::Id type_id) const = 0;
 
    virtual void addBootstrap(const std::string& /*host*/, const std::string& /*service*/) {};
    virtual void clearBootstrap() {};

    virtual void insertNode(const InfoHash& id, const SockAddr&) = 0;
    virtual void insertNode(const NodeExport& n) = 0;
 
    virtual void pingNode(SockAddr, DoneCallbackSimple&& cb = {}) = 0;
 
    virtual time_point periodic(const uint8_t* buf, size_t buflen, SockAddr, const time_point& now) = 0;
    virtual time_point periodic(
        const uint8_t* buf, size_t buflen, const sockaddr* from, socklen_t fromlen, const time_point& now)
        = 0;

    virtual void get(
        const InfoHash& key, GetCallback cb, DoneCallback donecb = {}, Value::Filter&& f = {}, Where&& w = {})
        = 0;
    virtual void get(
        const InfoHash& key, GetCallback cb, DoneCallbackSimple donecb = {}, Value::Filter&& f = {}, Where&& w = {})
        = 0;
    virtual void get(
        const InfoHash& key, GetCallbackSimple cb, DoneCallback donecb = {}, Value::Filter&& f = {}, Where&& w = {})
        = 0;
    virtual void get(
        const InfoHash& key, GetCallbackSimple cb, DoneCallbackSimple donecb, Value::Filter&& f = {}, Where&& w = {})
        = 0;

    virtual void query(const InfoHash& key, QueryCallback cb, DoneCallback done_cb = {}, Query&& q = {}) = 0;
    virtual void query(const InfoHash& key, QueryCallback cb, DoneCallbackSimple done_cb = {}, Query&& q = {}) = 0;

    virtual std::vector<Sp<Value>> getLocal(const InfoHash& key, const Value::Filter& f = {}) const = 0;

    virtual Sp<Value> getLocalById(const InfoHash& key, Value::Id vid) const = 0;

    virtual void put(const InfoHash& key,
                     Sp<Value>,
                     DoneCallback cb = nullptr,
                     time_point created = time_point::max(),
                     bool permanent = false)
        = 0;
    virtual void put(const InfoHash& key,
                     const Sp<Value>& v,
                     DoneCallbackSimple cb,
                     time_point created = time_point::max(),
                     bool permanent = false)
        = 0;
    virtual void put(const InfoHash& key,
                     Value&& v,
                     DoneCallback cb = nullptr,
                     time_point created = time_point::max(),
                     bool permanent = false)
        = 0;
    virtual void put(const InfoHash& key,
                     Value&& v,
                     DoneCallbackSimple cb,
                     time_point created = time_point::max(),
                     bool permanent = false)
        = 0;

    virtual std::vector<Sp<Value>> getPut(const InfoHash&) const = 0;

    virtual Sp<Value> getPut(const InfoHash&, const Value::Id&) const = 0;

    virtual bool cancelPut(const InfoHash&, const Value::Id&) = 0;

    virtual size_t listen(const InfoHash&, GetCallback, Value::Filter = {}, Where w = {}) = 0;
    virtual size_t listen(const InfoHash& key, GetCallbackSimple cb, Value::Filter f = {}, Where w = {}) = 0;
    virtual size_t listen(const InfoHash&, ValueCallback, Value::Filter = {}, Where w = {}) = 0;
 
    virtual bool cancelListen(const InfoHash&, size_t token) = 0;

    virtual void connectivityChanged(sa_family_t) = 0;
    virtual void connectivityChanged() = 0;

    virtual std::vector<NodeExport> exportNodes() const = 0;
 
    virtual std::vector<ValuesExport> exportValues() const = 0;
    virtual void importValues(const std::vector<ValuesExport>&) = 0;
 
    virtual NodeStats getNodesStats(sa_family_t af) const = 0;
 
    virtual std::string getStorageLog() const = 0;
    virtual std::string getStorageLog(const InfoHash&) const = 0;
 
    virtual std::string getRoutingTablesLog(sa_family_t) const = 0;
    virtual std::string getSearchesLog(sa_family_t) const = 0;
    virtual std::string getSearchLog(const InfoHash&, sa_family_t af = AF_UNSPEC) const = 0;
 
    virtual void dumpTables() const = 0;
    virtual std::vector<unsigned> getNodeMessageStats(bool in = false) = 0;

    virtual void setStorageLimit(size_t limit = 0) = 0;
    virtual size_t getStorageLimit() const = 0;

    virtual void setLocalStorageLimit(size_t limit = 0) = 0;
    virtual size_t getLocalStorageLimit() const = 0;

    virtual std::pair<size_t, size_t> getStoreSize() const = 0;
 
    virtual std::pair<size_t, size_t> getLocalStoreSize() const = 0;
 
    virtual std::vector<SockAddr> getPublicAddress(sa_family_t family = 0) = 0;
 
    virtual void setLogger(const std::shared_ptr<Logger>& l) { logger_ = l; }

    virtual void setLogFilter(const InfoHash& f)
    {
        if (logger_)
            logger_->setFilter(f);
    }
 
    virtual void setPushNotificationToken(const std::string&) {};
 
    virtual void setPushNotificationTopic(const std::string&) {};
    virtual void setPushNotificationPlatform(const std::string&) {};

    virtual PushNotificationResult pushNotificationReceived(const std::map<std::string, std::string>& data) = 0;
 
protected:
    std::shared_ptr<Logger> logger_ {};
    std::queue<std::function<void()>> onConnectCallbacks_ {};
};
 
} // namespace dht