Method do_sync

autokuma/src/sync.rs:217–348

(&mut self)

    }

    async fn do_sync(&mut self) -> Result<()> {
        let kuma = self.get_connection().await?;

        crate::migrations::migrate(&self.app_state, &kuma).await?;

        self.app_state.db.clean(
            &kuma
                .get_monitors()
                .await?
                .into_iter()
                .filter_map(|(_, monitor)| monitor.common().id().clone())
                .collect::<HashSet<_>>(),
            &kuma
                .get_notifications()
                .await?
                .into_iter()
                .filter_map(|notification| notification.id)
                .collect::<HashSet<_>>(),
            &kuma
                .get_docker_hosts()
                .await?
                .into_iter()
                .filter_map(|docker_host| docker_host.id)
                .collect::<HashSet<_>>(),
            &kuma
                .get_tags()
                .await?
                .into_iter()
                .filter_map(|tag| tag.tag_id)
                .collect::<HashSet<_>>(),
            &kuma
                .get_status_pages()
                .await?
                .into_iter()
                .filter_map(|(_, status_page)| status_page.slug)
                .collect::<HashSet<_>>(),
        )?;

        if let Some(auth_token) = kuma.get_auth_token().await {
            self.auth_token = Some(auth_token);
        }

        let current_entities = get_managed_entities(&self.app_state, &kuma).await?;

        let mut new_entities: HashMap<String, Entity> = HashMap::new();

        for source in &mut self.sources {
            trace!("Querying source: {}", source.name());
            let entities = source.get_entities().await?;
            trace!("Got {} entities from source", entities.len());
            new_entities.extend(entities);
        }

        let to_delete = current_entities
            .iter()
            .filter(|(id, _)| !new_entities.contains_key(*id))
            .collect_vec();