application_impl.hxx

Go to the documentation of this file.

#pragma once

#include <fc/network/http/websocket.hpp>
#include <fc/thread/parallel.hpp>

#include <graphene/app/application.hpp>
#include <graphene/app/api_access.hpp>
#include <graphene/chain/genesis_state.hpp>
#include <graphene/protocol/types.hpp>
#include <graphene/net/message.hpp>

namespace graphene { namespace app { namespace detail {


class application_impl : public net::node_delegate, public std::enable_shared_from_this<application_impl>
   {
   public:
      fc::optional<fc::temp_file> _lock_file;
      bool _is_block_producer = false;
      bool _force_validate = false;
      application_options _app_options;

      void reset_p2p_node(const fc::path& data_dir);

      void new_connection( const fc::http::websocket_connection_ptr& c );

      void reset_websocket_server();

      void reset_websocket_tls_server();

      explicit application_impl(application& self)
         : _self(self),
           _chain_db(std::make_shared<chain::database>())
      {
      }

      virtual ~application_impl();

      void set_block_production(bool producing_blocks);

      void set_api_limit();

      void initialize(const fc::path& data_dir, std::shared_ptr<boost::program_options::variables_map> options);
      void startup();

      fc::optional< api_access_info > get_api_access_info(const string& username)const;

      void set_api_access_info(const string& username, api_access_info&& permissions);

      bool has_item(const net::item_id& id) override;

      bool handle_block(const graphene::net::block_message& blk_msg, bool sync_mode,
                        std::vector<graphene::net::message_hash_type>& contained_transaction_msg_ids) override;

      void handle_transaction(const graphene::net::trx_message& transaction_message) override;

      void handle_message(const graphene::net::message& message_to_process) override;

      bool is_included_block(const graphene::chain::block_id_type& block_id);

      std::vector<graphene::net::item_hash_t> get_block_ids(
            const std::vector<graphene::net::item_hash_t>& blockchain_synopsis,
            uint32_t& remaining_item_count,
            uint32_t limit) override;

      graphene::net::message get_item(const graphene::net::item_id& id) override;

      graphene::chain::chain_id_type get_chain_id()const override;

      std::vector<graphene::net::item_hash_t> get_blockchain_synopsis(
            const graphene::net::item_hash_t& reference_point,
            uint32_t number_of_blocks_after_reference_point) override;

      void sync_status(uint32_t item_type, uint32_t item_count) override;

      void connection_count_changed(uint32_t c) override;

      uint32_t get_block_number(const graphene::net::item_hash_t& block_id) override;

      fc::time_point_sec get_block_time(const graphene::net::item_hash_t& block_id) override;

      graphene::net::item_hash_t get_head_block_id() const override;

      uint32_t estimate_last_known_fork_from_git_revision_timestamp(uint32_t unix_timestamp) const override;

      void error_encountered(const std::string& message, const fc::oexception& error) override;

      uint8_t get_current_block_interval_in_seconds() const override;

      void add_available_plugin( std::shared_ptr<abstract_plugin> p );

      void enable_plugin(const string& name);

      bool is_plugin_enabled(const string& name) const;

   private:
      void shutdown();

      void initialize_plugins() const;
      void startup_plugins() const;
      void shutdown_plugins() const;

      graphene::chain::genesis_state_type initialize_genesis_state() const;
      void open_chain_database() const;

      friend class graphene::app::application;

      application& _self;

      fc::path _data_dir;
      std::shared_ptr<boost::program_options::variables_map> _options;
      api_access _apiaccess;

      std::shared_ptr<graphene::chain::database>            _chain_db;
      std::shared_ptr<graphene::net::node>                  _p2p_network;
      std::shared_ptr<fc::http::websocket_server>      _websocket_server;
      std::shared_ptr<fc::http::websocket_tls_server>  _websocket_tls_server;

      std::map<string, std::shared_ptr<abstract_plugin>> _active_plugins;
      std::map<string, std::shared_ptr<abstract_plugin>> _available_plugins;

      bool _is_finished_syncing = false;

      string _node_info;

      fc::serial_valve valve;
   };

}}} // namespace graphene namespace app namespace detail