Idea: Refactor handling of background tasks in PeerSet

[jvff]

Motivation

The PeerSet currently keeps track of some initialization and background tasks necessary for zebra-network. These tasks are spawned in zebra_network::initialize and passed to the PeerSet using a oneshot channel. However, this task handling is something that's not core to the main purpose of the PeerSet (IMHO, I think the main purpose is to route requests to connected peers).

Designs

One idea for refactoring to try to simplify how tasks are handled in the PeerSet is to create a NetworkTasks helper type. A sketch of the idea follows:

pub struct NetworkTasks {
    startup_tasks: FuturesUnordered<JoinHandle<Result<(), BoxError>>>,
    background_tasks: FuturesUnordered<JoinHandle<Result<(), BoxError>>>,
}

impl NetworkTasks {
    pub fn spawn_startup_task<T>(&mut self, task: T)
    where
        T: Future<Output = Result<(), BoxError>>,
    {
        self.startup_tasks.push(tokio::spawn(task));
    }

    pub fn spawn_background_task<T>(&mut self, task: T)
    where
        T: Future<Output = Result<(), BoxError>>,
    {
        self.background_tasks.push(tokio::spawn(task));
    }

    fn poll_startup_tasks(self: Pin<&mut Self>) -> Poll<Result<(), TaskError>> {
        loop {
            match ready!(self.startup_tasks.poll_next()) {
                Some(Ok(())) => {}
                Some(Err(error)) => return Poll::Ready(Err(TaskError::StartUp(error))),
                None => return Poll::Ready(Ok(())),
            }
        }
    }

    fn poll_background_tasks(self: Pin<&mut Self>) -> Poll<Result<(), TaskError>> {
        match ready!(self.background_tasks.poll_next()) {
            Some(Ok(())) => return Poll::Ready(Err(TaskError::NoBackgroundTasks)),
            Some(Err(error)) => return Poll::Ready(Err(TaskError::Background(Some(error))),
            None => return Poll::Ready(Err(TaskError::Background(None))),
        }
    }
}

impl Future for NetworkTasks {
    type Output = Result<(), TaskError>;

    fn poll(self: Pin<&mut Self>, context: &mut Context) -> Poll<Self::Output> {
        match self.poll_startup_tasks() {
            Poll::Pending | Poll::Ready(Ok(())) => {}
            Poll::Ready(Err(error)) => return Poll::Ready(Err(error)),
        }

        self.poll_background_tasks()
    }
}

The PeerSet can just do self.network_tasks.poll() instead of self.poll_background_errors().