electroneum::basic::Validators Class Reference

#include <validators.h>

Public Member Functions
	Validators (cryptonote::BlockchainDB &db, cryptonote::i_cryptonote_protocol *pprotocol, bool testnet)
vector< string >	getApplicablePublicKeys (uint64_t height, bool convert_to_byte=false)
Validator	getValidatorByKey (string key)
bool	loadValidatorsList ()
string	getSerializedValidatorList ()
list_update_outcome	setValidatorsList (const string &v_list, bool saveToDB, bool isEmergencyUpdate=false)
bool	isValid ()
bool	isEnabled ()
void	enable ()
void	on_idle ()

Detailed Description

Definition at line 139 of file validators.h.

Constructor & Destructor Documentation

Validators()

electroneum::basic::Validators::Validators ( cryptonote::BlockchainDB & db, cryptonote::i_cryptonote_protocol * pprotocol, bool testnet )

inlineexplicit

Definition at line 169 of file validators.h.

                                                                                                                  : m_db(db), current_list_timestamp(0) {
          testnet ? this->http_client.set_server(this->testnet_endpoint_addr, this->testnet_endpoint_port, boost::none) :
                    this->http_client.set_server(this->endpoint_addr, this->endpoint_port, boost::none);
          this->testnet = testnet;
          this->m_p2p = pprotocol;
        };

Here is the call graph for this function:

Member Function Documentation

enable()

void electroneum::basic::Validators::enable ( )

inline

Definition at line 274 of file validators.h.

                             {
          this->status = ValidatorsState::Expired;
        }

getApplicablePublicKeys()

vector< string > electroneum::basic::Validators::getApplicablePublicKeys ( uint64_t height, bool convert_to_byte = false )

inline

Definition at line 176 of file validators.h.

                                                                                                   {
          vector<string> keys;
          all_of(this->list.begin(), this->list.end(), [&height, &keys, &convert_to_byte](std::unique_ptr<Validator> &v) {
              if (v->isWithinRange(height)) {
                const string k = convert_to_byte ? unhex(v->getPublicKey()) : v->getPublicKey();
                keys.push_back(k);
              }
              return true;
          });
          return keys;
        }

getSerializedValidatorList()

string electroneum::basic::Validators::getSerializedValidatorList ( )

inline

Definition at line 250 of file validators.h.

                                                   {
 
          if(this->status == ValidatorsState::NeedsUpdate || this->status == ValidatorsState::Expired) {
            return string("");
          }
 
          return this->serialized_v_list;
        }

getValidatorByKey()

Validator electroneum::basic::Validators::getValidatorByKey ( string key )

inline

Definition at line 188 of file validators.h.

                                                       {
          Validator result;
          all_of(this->list.begin(), this->list.end(), [&key, &result](std::unique_ptr<Validator> &v) {
              if (v->getPublicKey() == key) {
                result = v->getValidatorInfo();
              }
              return true;
          });
          return result;
        }

isEnabled()

bool electroneum::basic::Validators::isEnabled ( )

inline

Definition at line 270 of file validators.h.

                                {
          return this->status != ValidatorsState::Disabled;
        }

isValid()

bool electroneum::basic::Validators::isValid ( )

inline

Definition at line 266 of file validators.h.

                              {
          return this->status == ValidatorsState::Valid || this->status == ValidatorsState::NeedsUpdate;
        }

loadValidatorsList()

bool electroneum::basic::Validators::loadValidatorsList ( )

inline

Definition at line 199 of file validators.h.

                                         {
 
          v_list_struct_request req = AUTO_VAL_INIT(req);
          v_list_struct res = AUTO_VAL_INIT(res);
 
          // Try fetching list of validators from JSON endpoint
          if(this->status == ValidatorsState::Invalid || this->status == ValidatorsState::Expired || this->status == ValidatorsState::NeedsUpdate) {
            if (!get_http_json("/", res, this->http_client)) {
              LOG_PRINT_L1("Unable to get validator_list json from " << this->endpoint_addr << ":" << this->endpoint_port);
            }
 
            this->timeout = 60*60*24;
            list_update_outcome isJsonValid = validate_and_update(res, true);
 
            if(isJsonValid == list_update_outcome::Success || isJsonValid == list_update_outcome::Same_List) {
              MGINFO("Validators list loaded from JSON endpoint! Refresh in 12 hours");
              return true;
            }
 
            //If the list was old, invalid, or had an invalid public key, try getting list of validators from peers
              if(m_p2p->request_validators_list_to_all() && this->status == ValidatorsState::Valid) {
                this->timeout = 60*60*1;
                MGINFO("Validators list loaded from peers! Refresh in 1 hour");
                return true;
              }
 
              //Keep returning true during the grace period
              if(this->status == ValidatorsState::NeedsUpdate) {
                LOG_PRINT_L1("Validator List Grace Period");
                return true;
              }
 
              // If we there was an issue with getting the list from peers, try getting list of validators from db.
              // This code will only be reached at the daemon start if both endpoint & p2p list are unavailable.
              string v = m_db.get_validator_list();
              if(!v.empty()) {
                this->timeout = 60*60*1;
                list_update_outcome isDBListValid = setValidatorsList(v, true);
                if(isDBListValid == electroneum::basic::list_update_outcome::Success || isDBListValid == list_update_outcome::Same_List) {
                  MGINFO("Validators list loaded from database! Refresh in 1 hour");
                  return true;
                }
              }
 
 
            return false;
          }
 
          return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

on_idle()

void electroneum::basic::Validators::on_idle ( )

inline

Definition at line 278 of file validators.h.

                              {
          if(this->status != ValidatorsState::Disabled) {
            if(validate_expiration() != ValidatorsState::Valid) {
              m_load_validators_interval.do_call(boost::bind(&Validators::loadValidatorsList, this));
            }
          }
        }

Here is the call graph for this function:

setValidatorsList()

list_update_outcome electroneum::basic::Validators::setValidatorsList ( const string & v_list, bool saveToDB, bool isEmergencyUpdate = false )

inline

Definition at line 259 of file validators.h.

                                                                                                                        {
          v_list_struct res = AUTO_VAL_INIT(res);
          load_t_from_json(res, v_list);
 
          return validate_and_update(res, saveToDB, isEmergencyUpdate);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_basic/validators.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_basic/validators.cpp