dht_interface.h

/*
 *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
 *  Author: Sébastien Blin <sebastien.blin@savoirfairelinux.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include "infohash.h"
#include "log_enable.h"
 
#include <queue>
 
namespace dht {
 
namespace net {
    class DatagramSocket;
}
 
class OPENDHT_PUBLIC DhtInterface {
public:
    DhtInterface() = default;
    DhtInterface(const Logger& l) : logger_(std::make_shared<Logger>(l)) {};
    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 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 = DEFAULT_STORAGE_LIMIT) = 0;
    virtual size_t getStorageLimit() const = 0;
 
    virtual std::pair<size_t, size_t> getStoreSize() const = 0;
 
    virtual std::vector<SockAddr> getPublicAddress(sa_family_t family = 0) = 0;
 
    virtual void setLoggers(LogMethod error = {}, LogMethod warn = {}, LogMethod debug = {}) {
        if (logger_) {
            logger_->DBG = std::move(debug);
            logger_->WARN = std::move(warn);
            logger_->ERR = std::move(error);
        } else
            logger_= std::make_shared<Logger>(std::move(error), std::move(warn), std::move(debug));
    }
 
    virtual void setLogger(const Logger& l) {
        if (logger_)
            *logger_ = l;
        else
            logger_= std::make_shared<Logger>(l);
    }
 
    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 pushNotificationReceived(const std::map<std::string, std::string>& data) = 0;
 
protected:
    std::shared_ptr<Logger> logger_ {};
    std::queue<std::function<void()>> onConnectCallbacks_ {};
};
 
} // namespace dht