Method fetch_items_loop

src/Chain/libraries/net/Node.cpp:1093–1210

            }

            void NodeImpl::fetch_items_loop()
            {
                VERIFY_CORRECT_THREAD();
                while (!_fetch_item_loop_done.canceled())
                {
                    _items_to_fetch_updated = false;
                    dlog("beginning an iteration of fetch items (${count} items to fetch)",
                        ("count", _items_to_fetch.size()));

                    fc::time_point oldest_timestamp_to_fetch = fc::time_point::now() - fc::seconds(10 * 5);
                    fc::time_point next_peer_unblocked_time = fc::time_point::maximum();

                    // we need to construct a list of items to request from each peer first,
                    // then send the messages (in two steps, to avoid yielding while iterating)
                    // we want to evenly distribute our requests among our peers.
                    struct requested_item_count_index {};
                    struct peer_and_items_to_fetch
                    {
                        PeerConnectionPtr peer;
                        std::vector<ItemId> item_ids;
                        peer_and_items_to_fetch(const PeerConnectionPtr& peer) : peer(peer) {}
                        bool operator<(const peer_and_items_to_fetch& rhs) const { return peer < rhs.peer; }
                        size_t number_of_items() const { return item_ids.size(); }
                    };
                    typedef boost::multi_index_container<peer_and_items_to_fetch,
                        boost::multi_index::indexed_by<boost::multi_index::ordered_unique<boost::multi_index::member<peer_and_items_to_fetch, PeerConnectionPtr, &peer_and_items_to_fetch::peer> >,
                        boost::multi_index::ordered_non_unique<boost::multi_index::tag<requested_item_count_index>,
                        boost::multi_index::const_mem_fun<peer_and_items_to_fetch, size_t, &peer_and_items_to_fetch::number_of_items> > > > fetch_messages_to_send_set;
                    fetch_messages_to_send_set items_by_peer;

                    // initialize the fetch_messages_to_send with an empty set of items for all idle peers
                    for (const PeerConnectionPtr& peer : _active_connections)
                        if (peer->idle())
                            items_by_peer.insert(peer_and_items_to_fetch(peer));

                    // now loop over all items we want to fetch
                    for (auto item_iter = _items_to_fetch.begin(); item_iter != _items_to_fetch.end();)
                    {
                        if (item_iter->time_stamp < oldest_timestamp_to_fetch)
                        {
                            // this item has probably already fallen out of our peers' caches, we'll just ignore it.
                            // this can happen during flooding, and the _items_to_fetch could otherwise get clogged
                            // with a bunch of items that we'll never be able to request from any peer
                            wlog("Unable to fetch item ${item} before its likely expiration time, removing it from our list of items to fetch", ("item", item_iter->item));
                            item_iter = _items_to_fetch.erase(item_iter);
                        }
                        else
                        {
                            // find a peer that has it, we'll use the one who has the least requests going to it to load balance
                            bool item_fetched = false;
                            for (auto peer_iter = items_by_peer.get<requested_item_count_index>().begin(); peer_iter != items_by_peer.get<requested_item_count_index>().end(); ++peer_iter)
                            {
                                const PeerConnectionPtr& peer = peer_iter->peer;
                                // if they have the item and we haven't already decided to ask them for too many other items
                                if (peer_iter->item_ids.size() < ALP_NET_MAX_ITEMS_PER_PEER_DURING_NORMAL_OPERATION &&
                                    peer->inventory_peer_advertised_to_us.find(item_iter->item) != peer->inventory_peer_advertised_to_us.end())
                                {
                                    if (item_iter->item.item_type == thinkyoung::net::trx_message_type && peer->is_transaction_fetching_inhibited())