node.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <graphene/net/core_messages.hpp>
#include <graphene/net/message.hpp>
#include <graphene/net/peer_database.hpp>
 
#include <graphene/protocol/types.hpp>
 
namespace graphene { namespace net {
 
  using fc::variant_object;
  using graphene::protocol::chain_id_type;
 
  namespace detail
  {
    class node_impl;
  }
  using node_impl_ptr = std::shared_ptr<detail::node_impl>;
 
  // during network development, we need to track message propagation across the network
  // using a structure like this:
  struct message_propagation_data
  {
    fc::time_point received_time;
    fc::time_point validated_time;
    node_id_t originating_peer;
  };
 
   class node_delegate
   {
      public:
         virtual ~node_delegate() = default;
 
         virtual bool has_item( const net::item_id& id ) = 0;
 
         virtual bool handle_block( const graphene::net::block_message& blk_msg, bool sync_mode,
                                    std::vector<message_hash_type>& contained_transaction_msg_ids ) = 0;
 
         virtual void handle_transaction( const graphene::net::trx_message& trx_msg ) = 0;
 
         virtual void handle_message( const message& message_to_process ) = 0;
 
         virtual std::vector<item_hash_t> get_block_ids(const std::vector<item_hash_t>& blockchain_synopsis,
                                                        uint32_t& remaining_item_count,
                                                        uint32_t limit = 2000) = 0;
 
         virtual message get_item( const item_id& id ) = 0;
 
         virtual chain_id_type get_chain_id()const = 0;
 
         virtual std::vector<item_hash_t> get_blockchain_synopsis(const item_hash_t& reference_point,
                                                               uint32_t number_of_blocks_after_reference_point) = 0;
 
         virtual void     sync_status( uint32_t item_type, uint32_t item_count ) = 0;
 
         virtual void     connection_count_changed( uint32_t c ) = 0;
 
         virtual uint32_t get_block_number(const item_hash_t& block_id) = 0;
 
         virtual fc::time_point_sec get_block_time(const item_hash_t& block_id) = 0;
 
         virtual item_hash_t get_head_block_id() const = 0;
 
         virtual uint32_t estimate_last_known_fork_from_git_revision_timestamp(uint32_t unix_timestamp) const = 0;
 
         virtual void error_encountered(const std::string& message, const fc::oexception& error) = 0;
         virtual uint8_t get_current_block_interval_in_seconds() const = 0;
 
   };
 
   struct peer_status
   {
      uint32_t         version;
      fc::ip::endpoint host;
      fc::variant_object info;
   };
 
   class node : public std::enable_shared_from_this<node>
   {
      public:
        explicit node(const std::string& user_agent);
        virtual ~node();
 
        void close() const;
 
        void      set_node_delegate( std::shared_ptr<node_delegate> del ) const;
 
        void      load_configuration( const fc::path& configuration_directory ) const;
 
        virtual void      listen_to_p2p_network() const;
        virtual void      connect_to_p2p_network() const;
 
        void      add_node( const fc::ip::endpoint& ep ) const;
 
        /*****
         * @brief add a list of nodes to seed the p2p network
         * @param seeds a vector of url strings
         */
        void add_seed_nodes( const std::vector<std::string>& seeds ) const;
 
        /****
         * @brief add a node to seed the p2p network
         * @param in the url as a string
         */
        void add_seed_node( const std::string& in) const;
 
        virtual void connect_to_endpoint( const fc::ip::endpoint& ep ) const;
 
         void set_listen_endpoint( const fc::ip::endpoint& ep, bool wait_if_not_available ) const;
 
         void set_inbound_endpoint( const fc::ip::endpoint& ep ) const;
 
         void set_accept_incoming_connections( bool accept ) const;
 
         /***
          * Enable or disable connection attempts when new connections are advertised
          * @param connect true to attempt new connections, false otherwise
          */
         void set_connect_to_new_peers( bool connect ) const;
 
        virtual fc::ip::endpoint get_actual_listening_endpoint() const;
 
        /***
         * Allows the caller to determine how to respond to requests for peers
         * @param algo the algorithm to use ("exclude_list", "list", "nothing", "all")
         * @param advertise_or_exclude_list a list of nodes to
         *     advertise (if algo is "list") or exclude (if algo is "exclude_list")
         */
        void set_advertise_algorithm( const std::string& algo,
            const std::vector<std::string>& advertise_or_exclude_list = std::vector<std::string>() ) const;
 
        std::vector<peer_status> get_connected_peers() const;
 
        virtual uint32_t get_connection_count() const;
 
        virtual void  broadcast( const message& item_to_broadcast ) const;
        virtual void  broadcast_transaction( const signed_transaction& trx ) const
        {
           broadcast( trx_message(trx) );
        }
 
        virtual void sync_from( const item_id& current_head_block,
                                const std::vector<uint32_t>& hard_fork_block_numbers ) const;
 
        bool      is_connected() const;
 
        void set_advanced_node_parameters(const fc::variant_object& params) const;
        fc::variant_object get_advanced_node_parameters() const;
        message_propagation_data get_tx_propagation_data(
              const graphene::protocol::transaction_id_type& transaction_id) const;
        message_propagation_data get_block_propagation_data(
              const graphene::protocol::block_id_type& block_id) const;
        node_id_t get_node_id() const;
        void set_allowed_peers(const std::vector<node_id_t>& allowed_peers) const;
 
        void clear_peer_database() const;
 
        void set_total_bandwidth_limit(uint32_t upload_bytes_per_second, uint32_t download_bytes_per_second) const;
 
        fc::variant_object network_get_info() const;
        fc::variant_object network_get_usage_stats() const;
 
        std::vector<potential_peer_record> get_potential_peers() const;
 
        fc::variant_object get_call_statistics() const;
      protected:
        node_impl_ptr my;
   };
 
   using node_ptr = std::shared_ptr<node>;
 
} } // graphene::net
 
FC_REFLECT(graphene::net::message_propagation_data, (received_time)(validated_time)(originating_peer));
FC_REFLECT( graphene::net::peer_status, (version)(host)(info) );