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>

#include <list>

namespace graphene { namespace net {

  using fc::variant_object;
  using graphene::protocol::chain_id_type;

  namespace detail
  {
    class node_impl;
    struct node_impl_deleter
    {
      void operator()(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(){}

         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<fc::uint160_t>& contained_transaction_message_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:
        node(const std::string& user_agent);
        virtual ~node();

        void close();

        void      set_node_delegate( node_delegate* del );

        void      load_configuration( const fc::path& configuration_directory );

        virtual void      listen_to_p2p_network();
        virtual void      connect_to_p2p_network();

        void      add_node( const fc::ip::endpoint& ep );

        /*****
         * @brief add a list of nodes to seed the p2p network
         * @param seeds a vector of url strings
         */
        void add_seed_nodes( std::vector<std::string> seeds );

        /****
         * @brief add a node to seed the p2p network
         * @param in the url as a string
         */
        void add_seed_node( const std::string& in);

        virtual void connect_to_endpoint( const fc::ip::endpoint& ep );

        static std::vector<fc::ip::endpoint> resolve_string_to_ip_endpoints( const std::string& in );

        void      listen_on_endpoint( const fc::ip::endpoint& ep, bool wait_if_not_available );

        void accept_incoming_connections(bool accept);

        void      listen_on_port(uint16_t port, bool wait_if_not_available);

        virtual fc::ip::endpoint get_actual_listening_endpoint() const;

        std::vector<peer_status> get_connected_peers() const;

        virtual uint32_t get_connection_count() const;

        virtual void  broadcast( const message& item_to_broadcast );
        virtual void  broadcast_transaction( const signed_transaction& trx )
        {
           broadcast( trx_message(trx) );
        }

        virtual void      sync_from(const item_id& current_head_block, const std::vector<uint32_t>& hard_fork_block_numbers);

        bool      is_connected() const;

        void set_advanced_node_parameters(const fc::variant_object& params);
        fc::variant_object get_advanced_node_parameters();
        message_propagation_data get_transaction_propagation_data(const graphene::protocol::transaction_id_type& transaction_id);
        message_propagation_data get_block_propagation_data(const graphene::protocol::block_id_type& block_id);
        node_id_t get_node_id() const;
        void set_allowed_peers(const std::vector<node_id_t>& allowed_peers);

        void clear_peer_database();

        void set_total_bandwidth_limit(uint32_t upload_bytes_per_second, uint32_t download_bytes_per_second);

        fc::variant_object network_get_info() const;
        fc::variant_object network_get_usage_stats() const;

        std::vector<potential_peer_record> get_potential_peers() const;

        void disable_peer_advertising();
        fc::variant_object get_call_statistics() const;
      private:
        std::unique_ptr<detail::node_impl, detail::node_impl_deleter> my;
   };

    class simulated_network : public node
    {
    public:
      ~simulated_network();
      simulated_network(const std::string& user_agent) : node(user_agent) {}
      void      listen_to_p2p_network() override {}
      void      connect_to_p2p_network() override {}
      void      connect_to_endpoint(const fc::ip::endpoint& ep) override {}

      fc::ip::endpoint get_actual_listening_endpoint() const override { return fc::ip::endpoint(); }

      void      sync_from(const item_id& current_head_block, const std::vector<uint32_t>& hard_fork_block_numbers) override {}
      void      broadcast(const message& item_to_broadcast) override;
      void      add_node_delegate(node_delegate* node_delegate_to_add);

      virtual uint32_t get_connection_count() const override { return 8; }
    private:
      struct node_info;
      void message_sender(node_info* destination_node);
      std::list<node_info*> network_nodes;
    };


   typedef std::shared_ptr<node> node_ptr;
   typedef std::shared_ptr<simulated_network> simulated_network_ptr;

} } // graphene::net

FC_REFLECT(graphene::net::message_propagation_data, (received_time)(validated_time)(originating_peer));
FC_REFLECT( graphene::net::peer_status, (version)(host)(info) );