def step( self, local_inv=None, peer_table=None, peer_queue=None, con=None, path=None ):
        """
        Execute one round of the peer discovery algorithm:
        * Add at most 10 new peers from the pending peer queue
        (but ping them first, and drop hosts if the pending queue
        gets to be too long).
        * Execute one step of the MHRWDA algorithm.  Add any new
        peers from the neighbor sets discovered.
        * Remove at most 10 old, unresponsive peers from the peer DB.
        """

        if path is None:
            path = self.atlasdb_path

        if self.max_neighbors is None:
            self.max_neighbors = atlas_max_neighbors()
            log.debug("%s: max neighbors is %s" % (self.my_hostport, self.max_neighbors))

        current_peers = self.get_current_peers( peer_table=peer_table )

        # add some new peers 
        num_added = self.update_new_peers( 10, current_peers, peer_queue=peer_queue, peer_table=peer_table, con=con, path=path )

        # use MHRWDA to walk the peer graph.
        # first, begin the walk if we haven't already 
        if self.current_peer is None and len(current_peers) > 0:
            
            self.current_peer = current_peers[ random.randint(0,len(current_peers)-1) ]
            
            log.debug("%s: crawl %s" % (self.my_hostport, self.current_peer))
            peer_neighbors = self.get_neighbors( self.current_peer, peer_table=peer_table, path=path, con=con )

            if peer_neighbors is None or len(peer_neighbors) == 0:
                log.debug("%s: no peers from %s" % (self.my_hostport, self.current_peer))

                # try again later
                self.random_walk_reset()

            else:
                # success!
                self.current_peer_neighbors = [self.canonical_peer(p) for p in peer_neighbors]

                # don't talk to myself
                if self.my_hostport in self.current_peer_neighbors:
                    self.current_peer_neighbors.remove(self.my_hostport)

                log.debug("%s: neighbors of %s are (%s): %s" % (self.my_hostport, self.current_peer, len(self.current_peer_neighbors), ",".join(self.current_peer_neighbors)))

                # remember to contact these peers later
                self.new_peers = list(set( self.new_peers + peer_neighbors ))

        # can we walk now?
        if self.current_peer is not None:
            
            next_peer, next_peer_neighbors = self.random_walk_graph( self.prev_peer, self.prev_peer_degree, self.current_peer, self.current_peer_neighbors, con=con, path=path, peer_table=peer_table )
            if next_peer is not None and next_peer_neighbors is not None:
                # success!
                self.prev_peer = self.current_peer
                self.prev_peer_degree = len(self.current_peer_neighbors)
                self.current_peer = next_peer
                self.current_peer_neighbors = next_peer_neighbors
                
                # crawl new peers
                self.new_peers = list(set(self.new_peers + self.current_peer_neighbors))

            else:
                log.error("%s: failed to walk from %s" % (self.my_hostport, self.current_peer))
                self.random_walk_reset()


        # update the existing peer info
        num_removed = self.update_existing_peers( 10, con=con, path=path, peer_table=peer_table )
        return num_added, num_removed
Execute one round of the peer discovery algorithm:
        * Add at most 10 new peers from the pending peer queue
        (but ping them first, and drop hosts if the pending queue
        gets to be too long).
        * Execute one step of the MHRWDA algorithm.  Add any new
        peers from the neighbor sets discovered.
        * Remove at most 10 old, unresponsive peers from the peer DB.