Method sync_remote_packages

dev-scripts/src/sync/mirror/mod.rs:167–281

Download all official repository packages and extract all files that're interesting to us. Specifically: - `.BUILDINFO` - `.MTREE` - `.PKGINFO` - `.INSTALL` (Optional)

(&self)

    ///  - `.PKGINFO`
    ///  - `.INSTALL` (Optional)
    pub fn sync_remote_packages(&self) -> Result<(), Error> {
        let download_dir = self
            .cache_dir
            .as_ref()
            .join(DOWNLOAD_DIR)
            .join(PACKAGES_DIR);
        let target_dir = self.cache_dir.as_ref().join(PACKAGES_DIR);

        create_dir_all(&download_dir).map_err(|source| Error::IoPath {
            path: download_dir.clone(),
            context: "recursively creating the directory".to_string(),
            source,
        })?;

        create_dir_all(&target_dir).map_err(|source| Error::IoPath {
            path: target_dir.clone(),
            context: "recursively creating the directory".to_string(),
            source,
        })?;

        for repo in self.repositories.iter() {
            let repo_name = repo.to_string();
            info!("Downloading packages for repository {repo_name}");

            let file_source = format!("rsync://{}/{repo_name}/os/x86_64/", self.mirror);
            let download_dest = download_dir.join(&repo_name);
            let changed = self.download_packages(&repo_name, file_source, &download_dest)?;

            let packages: Vec<PathBuf> = if self.extract_all {
                let files: Vec<_> = read_dir(&download_dest)
                    .map_err(|source| Error::IoPath {
                        path: download_dest.to_path_buf(),
                        context: "reading entries in directory".to_string(),
                        source,
                    })?
                    .map(|result| {
                        result.map_err(|source| Error::IoPath {
                            path: download_dest.to_path_buf(),
                            context: "reading a directory entry".to_string(),
                            source,
                        })
                    })
                    .collect::<Result<_, Error>>()?;
                files
                    .into_iter()
                    .map(|entry| entry.path().to_owned())
                    .collect::<Vec<_>>()
            } else {
                changed
                    .into_iter()
                    .map(|pkg| download_dest.join(pkg))
                    .collect()
            }
            .into_iter()
            // Filter out any dotfiles.
            // Those might be temporary download artifacts from previous rsync runs.
            .filter(|entry| {
                if let Some(path) = entry.to_str() {