trader.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_de56e188fcfd89220cc987a4586be02f78f88b2010f135329f1082714d9eaaa6
#define USGOV_de56e188fcfd89220cc987a4586be02f78f88b2010f135329f1082714d9eaaa6
 
#include <us/gov/crypto/ripemd160.h>
#include <us/gov/crypto/ec.h>
#include <us/gov/socket/datagram.h>
#include <us/gov/socket/client.h>
#include <utility>
#include <thread>
#include <vector>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <fstream>
#include <sstream>
#include "trader_protocol.h"
 
namespace us{ namespace wallet {
    using namespace std;
    typedef us::gov::crypto::ec::keys keys;
 
    typedef us::gov::crypto::ripemd160::value_type hash_t;
    struct peer_t;
    struct wallet_local_api;
    //struct shop_t;
    using us::gov::socket::datagram;
    using namespace us::gov;
 
    struct wallet_daemon;
 
        struct trader {
            typedef trader_protocol protocol;
 
            trader(uint32_t host, uint16_t port, protocol* p, wallet_daemon&); //initiator constructor
            trader(const hash_t& trade_id, socket::client&, protocol* p, wallet_daemon&); //responder constructor
            void init();
            ~trader();
 
            void on_finish();
 
            static string ts();
 
 
            mutable ostringstream logos;
            mutable mutex mx_logos;
 
 
            template<typename type1>
            void dolog(const type1& arg1) const {
                logos << arg1 << ' ';
            }
 
            template<typename type1, typename... types>
            void dolog(const type1& arg1, const types& ... args) const {
                logos << arg1 << ' ';
                dolog(args...);
            }
 
            template<typename... Args>
            void olog(const Args&... args) const {
                lock_guard<mutex> lock(mx_logos);
                logos << ts() << ' ';
                dolog(args...);
                logos << endl;
            }
 
            enum state_t {
                state_offline,
                state_req_online,
                state_connecting,
                state_connect_failed,
                state_connected,
                state_online,
                num_states
            };
 
            static constexpr const char* statestr[num_states]={"offline","req_online","connecting","connect_failed","connected","online"};
 
            string reason;
 
            void unable(const string& r) {
                lock_guard<mutex> lock(mx);
                reason=r;
                if (cli!=0) {
                    cli->disconnect();
                }
            }
 
            bool exec(istream& cmd, ostream& os);
            void process_work(socket::client *c, unsigned char code, const string& data);
            void process_work(socket::client *c, unsigned char code, const vector<unsigned char>& data);
            void dump(const string& prefix, ostream&) const;
            void api_list(ostream&) const;
            void help(ostream&) const;
            void to_stream(ostream&) const;
            static trader* from_stream(istream&);
            void offline();
            void online(socket::client& cl, protocol*np);
            void run();
            void flush_command_queue();
 
            protocol* p;
            hash_t id;
            uint32_t host{0};
            uint16_t port{0};
 
            condition_variable cv;
            void set_state(state_t);
            void set_state_(state_t);
            void wait();
 
            void kill();
 
            thread* worker{0};
            bool resume{false};
            bool killed{false};
 
            vector<string> cmdq;
 
            socket::client* cli{0};
            bool initiator{false};
            wallet_daemon* demon{0};
            state_t state;
            mutable mutex mx;
 
            void show_log(ostream& os) const;
            void show_data(ostream& os) const;
 
        };
 
}}
 
#endif