Charlie Marsh
88a0c13865
## Summary
We currently maintain separate untar methods for sync and async, but we
only use the sync version when the user provides a local source
distribution. (Otherwise, we untar as we download the distribution.) In
my testing, this is actually slower anyway:
```
❯ python -m scripts.bench \
--uv-path ./target/release/main \
--uv-path ./target/release/uv \
./requirements.in --benchmark resolve-cold --min-runs 50
Benchmark 1: ./target/release/main (resolve-cold)
Time (mean ± σ): 835.2 ms ± 107.4 ms [User: 346.0 ms, System: 151.3 ms]
Range (min … max): 639.2 ms … 1051.0 ms 50 runs
Benchmark 2: ./target/release/uv (resolve-cold)
Time (mean ± σ): 750.7 ms ± 91.9 ms [User: 345.7 ms, System: 149.4 ms]
Range (min … max): 637.9 ms … 905.7 ms 50 runs
Summary
'./target/release/uv (resolve-cold)' ran
1.11 ± 0.20 times faster than './target/release/main (resolve-cold)'
```
98 lines
3.5 KiB
Rust
98 lines
3.5 KiB
Rust
use std::path::{Path, PathBuf};
|
|
use std::sync::Mutex;
|
|
|
|
use rayon::prelude::*;
|
|
use rustc_hash::FxHashSet;
|
|
use zip::ZipArchive;
|
|
|
|
use crate::vendor::{CloneableSeekableReader, HasLength};
|
|
use crate::Error;
|
|
|
|
/// Unzip a `.zip` archive into the target directory.
|
|
pub fn unzip<R: Send + std::io::Read + std::io::Seek + HasLength>(
|
|
reader: R,
|
|
target: &Path,
|
|
) -> Result<(), Error> {
|
|
// Unzip in parallel.
|
|
let archive = ZipArchive::new(CloneableSeekableReader::new(reader))?;
|
|
let directories = Mutex::new(FxHashSet::default());
|
|
(0..archive.len())
|
|
.par_bridge()
|
|
.map(|file_number| {
|
|
let mut archive = archive.clone();
|
|
let mut file = archive.by_index(file_number)?;
|
|
|
|
// Determine the path of the file within the wheel.
|
|
let Some(enclosed_name) = file.enclosed_name() else {
|
|
return Ok(());
|
|
};
|
|
|
|
// Create necessary parent directories.
|
|
let path = target.join(enclosed_name);
|
|
if file.is_dir() {
|
|
let mut directories = directories.lock().unwrap();
|
|
if directories.insert(path.clone()) {
|
|
fs_err::create_dir_all(path)?;
|
|
}
|
|
return Ok(());
|
|
}
|
|
|
|
if let Some(parent) = path.parent() {
|
|
let mut directories = directories.lock().unwrap();
|
|
if directories.insert(parent.to_path_buf()) {
|
|
fs_err::create_dir_all(parent)?;
|
|
}
|
|
}
|
|
|
|
// Copy the file contents.
|
|
let mut outfile = fs_err::File::create(&path)?;
|
|
std::io::copy(&mut file, &mut outfile)?;
|
|
|
|
// See `uv_extract::stream::unzip`. For simplicity, this is identical with the code there except for being
|
|
// sync.
|
|
#[cfg(unix)]
|
|
{
|
|
use std::fs::Permissions;
|
|
use std::os::unix::fs::PermissionsExt;
|
|
|
|
if let Some(mode) = file.unix_mode() {
|
|
// https://github.com/pypa/pip/blob/3898741e29b7279e7bffe044ecfbe20f6a438b1e/src/pip/_internal/utils/unpacking.py#L88-L100
|
|
let has_any_executable_bit = mode & 0o111;
|
|
if has_any_executable_bit != 0 {
|
|
let permissions = fs_err::metadata(&path)?.permissions();
|
|
fs_err::set_permissions(
|
|
&path,
|
|
Permissions::from_mode(permissions.mode() | 0o111),
|
|
)?;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
})
|
|
.collect::<Result<_, Error>>()
|
|
}
|
|
|
|
/// Extract the top-level directory from an unpacked archive.
|
|
///
|
|
/// The specification says:
|
|
/// > A .tar.gz source distribution (sdist) contains a single top-level directory called
|
|
/// > `{name}-{version}` (e.g. foo-1.0), containing the source files of the package.
|
|
///
|
|
/// This function returns the path to that top-level directory.
|
|
pub fn strip_component(source: impl AsRef<Path>) -> Result<PathBuf, Error> {
|
|
// TODO(konstin): Verify the name of the directory.
|
|
let top_level =
|
|
fs_err::read_dir(source.as_ref())?.collect::<std::io::Result<Vec<fs_err::DirEntry>>>()?;
|
|
match top_level.as_slice() {
|
|
[root] => Ok(root.path()),
|
|
[] => Err(Error::EmptyArchive),
|
|
_ => Err(Error::NonSingularArchive(
|
|
top_level
|
|
.into_iter()
|
|
.map(|entry| entry.file_name())
|
|
.collect(),
|
|
)),
|
|
}
|
|
}
|