daemon.h

Go to the documentation of this file.

/*
-------------------------------------------------------------------------------
                            PLEBBLE
-------------------------------------------------------------------------------
 Copyright (C) 2019-2020 KATLAS Technology. (http://katlastechnology.com)
 Copyright (C) 2017-2020 Marcos Mayorga. (mm@mm-studios.com)
 
 This file is part of our Plebble(R) Platform.
 
 The code below cannot be copied, used for any purpose other than the one
 agreed and/or distributed without the express permission of
 KATLAS Technology.
-------------------------------------------------------------------------------
 
 
*/
#ifndef USGOV_bf993116c1d89300316c0dd4fa2ef165d5b9128da89d33c44cfe50e95622fce8
#define USGOV_bf993116c1d89300316c0dd4fa2ef165d5b9128da89d33c44cfe50e95622fce8
 
#include <us/gov/auth/daemon.h>
#include <us/gov/crypto/ec.h>
#include <us/gov/socket/client.h>
#include <vector>
#include <thread>
#include <iostream>
#include <random>
#include <algorithm>
#include <sstream>
#include <chrono>
#include <cassert>
#include "peer_t.h"
#include <functional>
#include <tuple>
#include <unordered_set>
#include <atomic>
#include <us/gov/bgtask.h>
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace peer {
    using namespace std;
    using socket::datagram;
    struct daemon;
 
    struct mezzanine: bgtask {
        typedef bgtask b;
        mezzanine(daemon*);
        daemon* d;
    };
 
    struct daemon: auth::daemon, peer::mezzanine {
        typedef auth::daemon b;
        typedef peer::mezzanine t; 
        typedef socket::client client;
        typedef crypto::ec::keys keys;
        typedef keys::pub_t pub_t;
        typedef pub_t::hash_t hash_t;
 
        daemon();
        daemon(uint16_t port, uint16_t pport, uint8_t edges, uint8_t devices, uint8_t workers);
        ~daemon() override;
        void dump(const string& prefix, ostream&) const;
        void visit(const function<void(socket::client&)>& visitor);
        vector<pair<uint32_t,uint16_t>> list_neighbours() const;   
        vector<pair<uint32_t,uint16_t>> list_dev_neighbours() const;
        void purge_idle();
        ko start() override;
        ko wait_ready(const chrono::system_clock::time_point& deadline) const override;
        void stop() override;
        void join() override;
        bool is_active() const { return t::is_active(); }
        inline void wakeup() { b::wakeup(); }
        inline bool isup() const { return b::isup(); }
        void wait();
        void dump_random_nodes(size_t num, ostream&os) const;
        bool lookup_node(const hash_t& p, ostream& os) const;
        void on_destroy(client&) override;
        bool process_work(socket::peer_t *p, datagram*d) override;
        virtual void remote_port(const crypto::ec::keys::pub_t&, uint16_t port) {};
        void test_connectivity();
 
        struct account_t {
            account_t() {} // fields contain garbage. think efficiency before initializing them for no reason other than your obssession of keeping everything under over-control.
            account_t(uint32_t net_address, uint16_t port, uint16_t seen);
            account_t(const account_t& other);
            account_t& operator =(int zero);
            bool operator == (const account_t& other) const;
            account_t& operator = (const account_t& other);
            void to_stream(ostream& os) const;
            void from_stream(istream& os);
            void from_stream_prev(istream& os);
            void dump(ostream&) const;
            void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
            void hash_data(crypto::ripemd160&) const;
            void dump_as_seeds(ostream&) const;
            ko check() const;
 
            uint32_t net_address;
            uint16_t port;
            uint16_t seen;
            //int8_t distance{-1}; //0 closed, >0 ms roundtrip latency;
        };
 
        struct nodes_t: map<hash_t,account_t> {
            typedef account_t account_type;
            typedef hash_t index_type;
            void to_stream(ostream& os) const;
            void from_stream(istream& os);
            void from_stream_prev(istream& os);
            void dump(const string& prefix, ostream&) const;
            void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
            void hash_data(crypto::ripemd160&) const;
            void dump_as_seeds(ostream&) const;
            void collect_as_wallet_endpoints(vector<tuple<hash_t,uint32_t,uint16_t>>&) const;
            static ko check(const hash_t& id, const account_t&);
        };
 
        struct grid_t:vector<client*> {
            grid_t(): bi(end()) {}
            bool add(client&, bool check_unique);
            bool ended(client*);
            void dump(ostream&) const;
            void watch(ostream&) const;
            socket::client* prepare_worker_send(unordered_set<const socket::client*>& visited);
            bool find(const hash_t&) const;
            int num_edges_minage(int secs_old) const;
 
            iterator bi;
            mutable mutex mx;
            
            struct faillog_t:deque<string> {
                mutable mutex mx;
                void add(uint32_t a, uint16_t p);
                void dump(ostream& os) const;
            };
            faillog_t faillog;
        };
 
        #ifdef CFG_TOPOLOGY_MESH
        virtual bool wait_rnd_before_start() const { return true; }
        #endif
 
        //------ ring/mesh implementations
        void grid_rotate(nodes_t&);
        void run();
        void onwakeup();
        //----/- ring/mesh implementations
 
        void set_seed_nodes(const vector<pair<uint32_t,uint16_t>>&);
        ko add_seed_node(const pair<uint32_t,uint16_t>&);
        ko add_seed_node_(const pair<uint32_t,uint16_t>&);
        void set_nodes(const vector<pair<hash_t,pair<uint32_t,uint16_t>>>&);
        ko add_node_(const pair<hash_t,pair<uint32_t,uint16_t>>&);
        void grid_setcur();
        void disconnect_one();
        client* grid_connect(uint32_t netaddr, uint16_t port);
        bool grid_connect_test(peer::peer_t*p, uint32_t netaddr, uint16_t port,ostream& os);
        inline nodes_t& get_nodes() { return nodes; }
        inline const nodes_t& get_nodes() const { return nodes; }
 
        client* cli{nullptr};
        mutable mutex mx_nodes;
        mutex mx_hall;
        nodes_t hall;
        nodes_t seed_nodes;
        mutex mx_seed_nodes;
        uint8_t edges;
        grid_t grid;
    private:
        nodes_t nodes;
 
    public:
        condition_variable cv;
        hash_t myself;
        chrono::system_clock::time_point tlo;
        bool force_seeds{false};
        grid_t grid_dev;
    };
 
}
}}
 
#endif