app.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_7dffbbfc737462a907fd04b004cc37b5831ebb01a4bec16ea1b2ff1f59b92301
#define USGOV_7dffbbfc737462a907fd04b004cc37b5831ebb01a4bec16ea1b2ff1f59b92301
 
#include <us/gov/auth.h>
#include <us/gov/engine.h>
#include <vector>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <us/gov/socket/datagram.h>
#include <us/gov/crypto/crypto.h>
#include <us/gov/engine/diff.h>
#include "protocol.h"
#include <chrono>
#include <cassert>
#include <map>
#include <atomic>
#include <mutex>
#include <us/gov/engine/evidence.h>
#include <us/gov/config.h>
 
namespace us { namespace gov {
namespace engine {
    struct daemon;
}
namespace sys {
 
    using namespace std;
    using socket::datagram;
    using engine::local_deltas;
    using crypto::ripemd160;
    using crypto::ec;
    using engine::peer_t;
 
    typedef crypto::ec::keys keys;
    typedef keys::pub_t pubkey_t;
    typedef ripemd160 hasher_t;
    typedef hasher_t::value_type hash_t;
    typedef int64_t cash_t;
    typedef engine::evidence evidence;
 
    static const hash_t min_locking_program(10000);
 
    struct install_script_response;
    struct install_script;
    struct app:engine::app {
        typedef engine::app b;
 
        static pubkey_t automatic_updates_subscription;
 
        struct sensor_t {
            sensor_t();
            virtual ~sensor_t() {}
            void to_stream(ostream&) const;
            void from_stream(istream&);
            void from_stream_prev(istream&);
            void dump(ostream& os) const;
            void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
            void hash_data(crypto::ripemd160&) const;
 
 
            struct iodata {
                //iodata() {}
                //iodata(const socket::datagram::iodata&);
                struct data {
                    //void to_stream(ostream&) const;
                    //void from_stream(istream&);
                    void from_stream_prev(istream&);
                    //void dump(ostream&) const;
                    //void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                    //void hash_data(crypto::ripemd160&) const;
 
                    uint32_t num{0};
                    size_t bytes{0};
                };
                //void to_stream(ostream&) const;
                //void from_stream(istream&);
                void from_stream_prev(istream&);
                //void dump(ostream&) const;
                //void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                //void hash_data(crypto::ripemd160&) const;
 
                data sent;
                data received;
            };
 
            struct io_t: map<uint16_t,iodata> {
                //void to_stream(ostream&) const;
                //void from_stream(istream&);
                void from_stream_prev(istream&);
                //void from_counters();
                //void dump(ostream&) const;
                //void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const;
                //void hash_data(crypto::ripemd160&) const;
 
            };
/*
            uint8_t num_cores{0};
            uint32_t bogomips;
            float load_avg_15;
            uint32_t swap_free;
            uint32_t ram_free;
            uint32_t disk_free;
            io_t io;
            float govd_pcpu;
            float govd_pmem;
            float walletd_pcpu;
            float walletd_pmem;
            uint16_t max_edges;
            bool in_sync;
            vector<pair<uint32_t,uint16_t>> edges;
*/
        };
 
        struct local_delta:engine::app::local_delta {
            typedef engine::app::local_delta b;
            local_delta& operator =(const local_delta& other) { id=other.id; sensor=other.sensor; return *this; }
            local_delta& operator =(int zero)=delete;// { sensor.clear(); return *this; }
            local_delta();
            local_delta(const local_delta& other): sensor(other.sensor), id(other.id) {}
            bool operator == (const local_delta& other) const=delete;
 
            ~local_delta() override;
            int app_id() const override;
            void to_stream(ostream&) const override;
            void from_stream(istream&) override;
            void from_stream_prev(istream&) override;
            void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const override;
            void hash_data(crypto::ripemd160&) const override;
 
            hash_t id;
            sensor_t sensor;
 
            mutable hash_t hash{0};
            const hash_t& get_hash() const;
            hash_t compute_hash() const;
        };
 
        struct sensors_t:map<hash_t,sensor_t> {
            void dump(ostream& os) const;
            void to_stream(ostream&) const;
            void from_stream(istream&);
            void from_stream_prev(istream&);
        };
 
        struct delta:engine::app::delta {
            typedef engine::app::delta b;
            delta();
            delta(const delta&)=delete;
            delta& operator = (const delta&)=delete;
            ~delta() override;
            uint64_t merge(engine::app::local_delta* other0) override;
            void end_merge() override;
            void to_stream(ostream& os) const override;
            static delta* from_stream(istream& is);
            static delta* from_stream_prev(istream& is);
            local_delta g;
 
            struct merger:sensors_t {
                void merge(const sensor_t&);
            };
 
            merger m;
         };
 
        struct db_t {
            db_t();
            db_t(const db_t&)=delete;
            db_t& operator = (const db_t&)=delete;
            db_t(db_t&& other);
            ~db_t();
            void dump(ostream& os) const;
            void clear();
            void to_stream(ostream&) const;
            void from_stream(istream&);
            void from_stream_prev(istream&);
 
            mutable mutex mx;
            sensors_t sensors;
        };
 
        constexpr static const char* name={"sys"};
        static constexpr int id() { return 1; }
 
        app(engine::daemon&);
        app(const app&)=delete;
        app& operator = (const app&)=delete;
        ~app() override;
        engine::app::local_delta* create_local_delta() override;
        bool process_query(peer_t *, datagram*) override;
        static evidence* evidence_from_stream(uint8_t evid, istream& is); // const override;
        string get_name() const override { return name; }
        void import(const engine::app::delta&, const engine::pow_t&) override;
        bool process(const evidence&) override;
        bool process(const install_script& t);
        bool process(const install_script_response& t);
 
        void save_db(ostream&) const override;
        bool load_db(istream&) override;
        bool load_db_prev(istream&) override;
        void clear() override;
        void dump_policies(ostream& os) const;
        int get_id() const override { return id(); }
        bool shell_command(istream&, ostream&) override;
        void maintenance(int code, const hash_t& jobid);
        void send_response(const string& response, const hash_t& job);
        string exec(const string& cmd) const;
 
        string src_hash;
        string us_cash_android_hash;
 
        db_t db;
    };
 
}}
}
 
namespace std {
    template <>
    struct hash<us::gov::sys::app::local_delta> {
        size_t operator()(const us::gov::sys::app::local_delta&) const;
    };
}
 
#endif