Method run

autokuma/src/sync.rs:358–402

(&mut self)

    }

    pub async fn run(&mut self) {
        if let Err(err) = self.init().await {
            error!("Encountered error during init: {}", err);
            return;
        }

        async fn shutdown_signal() {
            futures_util::future::select(
                tokio::signal::ctrl_c().map(|_| ()).boxed(),
                #[cfg(unix)]
                tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
                    .unwrap()
                    .recv()
                    .map(|_| ())
                    .boxed(),
                #[cfg(not(unix))]
                futures_util::future::pending::<()>(),
            )
            .await;
        }

        loop {
            if let Err(err) = self.do_sync().await {
                warn!("Encountered error during sync: {}", err);
            }

            match futures_util::future::select(
                tokio::time::sleep(Duration::from_secs_f64(self.app_state.config.sync_interval))
                    .boxed(),
                shutdown_signal().boxed(),
            )
            .await
            {
                futures_util::future::Either::Left(_) => {}
                futures_util::future::Either::Right(_) => break,
            }
        }

        log::info!("Shutting down...");
        for source in &mut self.sources {
            _ = source.shutdown().await.log_error(std::module_path!(), |e| {
                format!("Failed to gracefully shutdown source: {}", e)
            });
        }
    }
}