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_1a04abafd244aa56917030342d01e6017e089433f96dd01ee598fed0d91162dd
#define USGOV_1a04abafd244aa56917030342d01e6017e089433f96dd01ee598fed0d91162dd
 
#include <us/gov/relay.h>
#include <us/gov/crypto/ripemd160.h>
#include <iostream>
#include <vector>
#include <set>
#include "fileattr_t.h"
#include <us/gov/bgtask.h>
 
namespace us { namespace gov {
namespace dfs {
    using namespace std;
    typedef relay::peer_t peer_t;
    using socket::datagram;
    typedef crypto::ripemd160 hasher_t;
    typedef hasher_t::value_type hash_t;
 
    struct daemon;
 
    struct mezzanine: bgtask {
        typedef bgtask b;
        mezzanine(daemon*);
        daemon* d;
    };
 
    struct daemon:relay::daemon, dfs::mezzanine {
        typedef relay::daemon b;
        typedef dfs::mezzanine t; 
        daemon();
        daemon(uint16_t port, uint16_t pport, uint8_t edges, uint8_t devices, int workers, const vector<pair<uint32_t,uint16_t>>& sn);
        virtual ~daemon();
        daemon(const daemon&)=delete;
        daemon& operator =(const daemon&)=delete;
        virtual bool process_work(socket::peer_t *c, datagram*d) override;
        void receive_file(peer_t* c, datagram* d);
        void dump(const string&prefix, ostream&) const;
        void send_file(peer_t* c, datagram* request);
        void save(const string& hash, const vector<uint8_t>& data, int propagate);
        string load(const string& hash);
        static string resolve_filename(const string& filename);
        virtual bool check_dfs_permission(const hash_t& addr) const;
        void wait();
        void run();
        void onwakeup();
        ko start() override;
        ko wait_ready(const chrono::system_clock::time_point& deadline) const override;
        void stop() override;
        void join() override;
        void wakeup() { b::wakeup(); }
        bool isup() const { return b::isup(); }
 
        condition_variable cv;
        mutable mutex mx;
        void index_set(const vector<pair<hash_t,uint32_t>>&);
        void index_add(const hash_t&, uint32_t sz);
        void index_rm(const hash_t&);
        void index_clear();
        void rm_file(const hash_t&h);
        size_t rm_files(const set<hash_t>& exclude);
        unordered_map<hash_t,uint32_t> index;
        string fsroot;
    };
 
}
}}
 
#endif