Method terminate_inactive_connections_loop

libraries/net/node.cpp:1310–1496

    }

    void node_impl::terminate_inactive_connections_loop()
    {
      VERIFY_CORRECT_THREAD();
      std::list<peer_connection_ptr> peers_to_disconnect_gently;
      std::list<peer_connection_ptr> peers_to_disconnect_forcibly;
      std::list<peer_connection_ptr> peers_to_send_keep_alive;
      std::list<peer_connection_ptr> peers_to_terminate;

      _recent_block_interval_in_seconds = _delegate->get_current_block_interval_in_seconds();

      // Disconnect peers that haven't sent us any data recently
      // These numbers are just guesses and we need to think through how this works better.
      // If we and our peers get disconnected from the rest of the network, we will not
      // receive any blocks or transactions from the rest of the world, and that will
      // probably make us disconnect from our peers even though we have working connections to
      // them (but they won't have sent us anything since they aren't getting blocks either).
      // This might not be so bad because it could make us initiate more connections and
      // reconnect with the rest of the network, or it might just futher isolate us.
      {
        // As usual, the first step is to walk through all our peers and figure out which
        // peers need action (disconneting, sending keepalives, etc), then we walk through 
        // those lists yielding at our leisure later.
        ASSERT_TASK_NOT_PREEMPTED();

        uint32_t handshaking_timeout = _peer_inactivity_timeout;
        fc::time_point handshaking_disconnect_threshold = fc::time_point::now() - fc::seconds(handshaking_timeout);
        for( const peer_connection_ptr handshaking_peer : _handshaking_connections )
          if( handshaking_peer->connection_initiation_time < handshaking_disconnect_threshold &&
              handshaking_peer->get_last_message_received_time() < handshaking_disconnect_threshold &&
              handshaking_peer->get_last_message_sent_time() < handshaking_disconnect_threshold )
          {
            wlog( "Forcibly disconnecting from handshaking peer ${peer} due to inactivity of at least ${timeout} seconds",
                  ( "peer", handshaking_peer->get_remote_endpoint() )("timeout", handshaking_timeout ) );
            wlog("Peer's negotiating status: ${status}, bytes sent: ${sent}, bytes received: ${received}",
                  ("status", handshaking_peer->negotiation_status)
                  ("sent", handshaking_peer->get_total_bytes_sent())
                  ("received", handshaking_peer->get_total_bytes_received()));
            handshaking_peer->connection_closed_error = fc::exception(FC_LOG_MESSAGE(warn, "Terminating handshaking connection due to inactivity of ${timeout} seconds.  Negotiating status: ${status}, bytes sent: ${sent}, bytes received: ${received}",
                                                                                      ("peer", handshaking_peer->get_remote_endpoint())
                                                                                      ("timeout", handshaking_timeout)
                                                                                      ("status", handshaking_peer->negotiation_status)
                                                                                      ("sent", handshaking_peer->get_total_bytes_sent())
                                                                                      ("received", handshaking_peer->get_total_bytes_received())));
            peers_to_disconnect_forcibly.push_back( handshaking_peer );
          }

        // timeout for any active peers is two block intervals
        uint32_t active_disconnect_timeout = 10 * _recent_block_interval_in_seconds;
        uint32_t active_send_keepalive_timeout = active_disconnect_timeout / 2;
        
        // set the ignored request time out to 1 second.  When we request a block
        // or transaction from a peer, this timeout determines how long we wait for them
        // to reply before we give up and ask another peer for the item.
        // Ideally this should be significantly shorter than the block interval, because
        // we'd like to realize the block isn't coming and fetch it from a different 
        // peer before the next block comes in.  At the current target of 3 second blocks,
        // 1 second seems reasonable.  When we get closer to our eventual target of 1 second 
        // blocks, this will need to be re-evaluated (i.e., can we set the timeout to 500ms