Why futures::executor::block_on while having a runtime?

[Xuanwo]

We have code like the following:

pub fn connect_flight(&mut self, runtime: &Arc<Runtime>) -> Result<()> {
    let config = self.config.clone();
    let target_address = self.target_address.clone();
    let flight_client = self.flight_client.clone();
    let connect_res_future = runtime.spawn(async move {
        let connection = Self::create_client(config, &target_address).await?;
        let mut flight_client = flight_client.lock();
        *flight_client = Some(connection);
        Ok(())
    });

    futures::executor::block_on(async move {
        match connect_res_future.await {
            Ok(res) => res,
            Err(join_error) => match join_error.is_panic() {
                false => Err(ErrorCode::TokioError("Cancel tokio task.")),
                true => {
                    let cause = join_error.into_panic();
                    match cause.downcast_ref::<&'static str>() {
                        None => match cause.downcast_ref::<String>() {
                            None => Err(ErrorCode::PanicError("Sorry, unknown panic message")),
                            Some(message) => Err(ErrorCode::PanicError(message.to_string())),
                        },
                        Some(message) => Err(ErrorCode::PanicError(message.to_string())),
                    }
                }
            },
        }
    })
}

Can we use runtime.block_on() directly here?

cc @zhang2014

---

Part of #4378

[zhang2014]

Can we use runtime.block_on() directly here?

I'm not sure if this will make spawn hang(I will try to refactor this).