| // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| extern mod extra; |
| |
| use target::*; |
| use package_id::PkgId; |
| use std::path::Path; |
| use std::os; |
| use context::*; |
| use crate::Crate; |
| use messages::*; |
| use source_control::{git_clone, git_clone_general}; |
| use path_util::{find_dir_using_rust_path_hack, default_workspace, make_dir_rwx_recursive}; |
| use util::compile_crate; |
| use workspace::is_workspace; |
| use workcache_support; |
| use workcache_support::crate_tag; |
| use extra::workcache; |
| |
| // An enumeration of the unpacked source of a package workspace. |
| // This contains a list of files found in the source workspace. |
| #[deriving(Clone)] |
| pub struct PkgSrc { |
| /// Root of where the package source code lives |
| workspace: Path, |
| // Directory to start looking in for packages -- normally |
| // this is workspace/src/id but it may be just workspace |
| start_dir: Path, |
| id: PkgId, |
| libs: ~[Crate], |
| mains: ~[Crate], |
| tests: ~[Crate], |
| benchs: ~[Crate], |
| } |
| |
| impl ToStr for PkgSrc { |
| fn to_str(&self) -> ~str { |
| fmt!("Package ID %s in start dir %s [workspace = %s]", |
| self.id.to_str(), |
| self.start_dir.to_str(), self.workspace.to_str()) |
| } |
| } |
| condition! { |
| // #6009: should this be pub or not, when #8215 is fixed? |
| build_err: (~str) -> ~str; |
| } |
| |
| impl PkgSrc { |
| |
| pub fn new(workspace: Path, use_rust_path_hack: bool, id: PkgId) -> PkgSrc { |
| use conditions::nonexistent_package::cond; |
| |
| debug!("Checking package source for package ID %s, \ |
| workspace = %s use_rust_path_hack = %?", |
| id.to_str(), workspace.to_str(), use_rust_path_hack); |
| |
| let mut to_try = ~[]; |
| if use_rust_path_hack { |
| to_try.push(workspace.clone()); |
| } else { |
| let result = workspace.push("src").push_rel(&id.path.pop()).push(fmt!("%s-%s", |
| id.short_name, id.version.to_str())); |
| to_try.push(result); |
| to_try.push(workspace.push("src").push_rel(&id.path)); |
| } |
| |
| debug!("Checking dirs: %?", to_try.map(|s| s.to_str()).connect(":")); |
| |
| let path = to_try.iter().find(|&d| os::path_exists(d)); |
| |
| let dir: Path = match path { |
| Some(d) => (*d).clone(), |
| None => { |
| // See if any of the prefixes of this package ID form a valid package ID |
| // That is, is this a package ID that points into the middle of a workspace? |
| for (prefix, suffix) in id.prefixes_iter() { |
| let package_id = PkgId::new(prefix.to_str()); |
| let path = workspace.push("src").push_rel(&package_id.path); |
| debug!("in loop: checking if %s is a directory", path.to_str()); |
| if os::path_is_dir(&path) { |
| let ps = PkgSrc::new(workspace.clone(), |
| use_rust_path_hack, |
| PkgId::new(prefix.to_str())); |
| debug!("pkgsrc: Returning [%s|%s|%s]", workspace.to_str(), |
| ps.start_dir.push_rel(&suffix).to_str(), ps.id.to_str()); |
| |
| return PkgSrc { |
| workspace: workspace, |
| start_dir: ps.start_dir.push_rel(&suffix), |
| id: ps.id, |
| libs: ~[], |
| mains: ~[], |
| tests: ~[], |
| benchs: ~[] |
| } |
| |
| }; |
| } |
| |
| // Ok, no prefixes work, so try fetching from git |
| let mut ok_d = None; |
| for w in to_try.iter() { |
| debug!("Calling fetch_git on %s", w.to_str()); |
| let gf = PkgSrc::fetch_git(w, &id); |
| for p in gf.iter() { |
| ok_d = Some(p.clone()); |
| break; |
| } |
| if ok_d.is_some() { break; } |
| } |
| match ok_d { |
| Some(d) => d, |
| None => { |
| if use_rust_path_hack { |
| match find_dir_using_rust_path_hack(&id) { |
| Some(d) => d, |
| None => { |
| cond.raise((id.clone(), |
| ~"supplied path for package dir does not \ |
| exist, and couldn't interpret it as a URL fragment")) |
| } |
| } |
| } |
| else { |
| cond.raise((id.clone(), |
| ~"supplied path for package dir does not \ |
| exist, and couldn't interpret it as a URL fragment")) |
| } |
| } |
| } |
| } |
| }; |
| debug!("For package id %s, returning %s", id.to_str(), dir.to_str()); |
| |
| if !os::path_is_dir(&dir) { |
| cond.raise((id.clone(), ~"supplied path for package dir is a \ |
| non-directory")); |
| } |
| |
| debug!("pkgsrc: Returning {%s|%s|%s}", workspace.to_str(), |
| dir.to_str(), id.to_str()); |
| |
| PkgSrc { |
| workspace: workspace, |
| start_dir: dir, |
| id: id, |
| libs: ~[], |
| mains: ~[], |
| tests: ~[], |
| benchs: ~[] |
| } |
| } |
| |
| /// Try interpreting self's package id as a git repository, and try |
| /// fetching it and caching it in a local directory. Return the cached directory |
| /// if this was successful, None otherwise. Similarly, if the package id |
| /// refers to a git repo on the local version, also check it out. |
| /// (right now we only support git) |
| pub fn fetch_git(local: &Path, pkgid: &PkgId) -> Option<Path> { |
| use conditions::failed_to_create_temp_dir::cond; |
| |
| // We use a temporary directory because if the git clone fails, |
| // it creates the target directory anyway and doesn't delete it |
| |
| let scratch_dir = extra::tempfile::mkdtemp(&os::tmpdir(), "rustpkg"); |
| let clone_target = match scratch_dir { |
| Some(d) => d.push("rustpkg_temp"), |
| None => cond.raise(~"Failed to create temporary directory for fetching git sources") |
| }; |
| |
| debug!("Checking whether %s (path = %s) exists locally. Cwd = %s, does it? %?", |
| pkgid.to_str(), pkgid.path.to_str(), |
| os::getcwd().to_str(), |
| os::path_exists(&pkgid.path)); |
| |
| if os::path_exists(&pkgid.path) { |
| debug!("%s exists locally! Cloning it into %s", |
| pkgid.path.to_str(), local.to_str()); |
| // Ok to use local here; we know it will succeed |
| git_clone(&pkgid.path, local, &pkgid.version); |
| return Some(local.clone()); |
| } |
| |
| if pkgid.path.components().len() < 2 { |
| // If a non-URL, don't bother trying to fetch |
| return None; |
| } |
| |
| let url = fmt!("https://%s", pkgid.path.to_str()); |
| debug!("Fetching package: git clone %s %s [version=%s]", |
| url, clone_target.to_str(), pkgid.version.to_str()); |
| |
| if git_clone_general(url, &clone_target, &pkgid.version) { |
| // Since the operation succeeded, move clone_target to local. |
| // First, create all ancestor directories. |
| if make_dir_rwx_recursive(&local.pop()) |
| && os::rename_file(&clone_target, local) { |
| Some(local.clone()) |
| } |
| else { |
| None |
| } |
| } |
| else { |
| None |
| } |
| } |
| |
| |
| // If a file named "pkg.rs" in the start directory exists, |
| // return the path for it. Otherwise, None |
| pub fn package_script_option(&self) -> Option<Path> { |
| let maybe_path = self.start_dir.push("pkg.rs"); |
| debug!("package_script_option: checking whether %s exists", maybe_path.to_str()); |
| if os::path_exists(&maybe_path) { |
| Some(maybe_path) |
| } |
| else { |
| None |
| } |
| } |
| |
| /// True if the given path's stem is self's pkg ID's stem |
| fn stem_matches(&self, p: &Path) -> bool { |
| p.filestem().map_default(false, |p| { p == &self.id.short_name.as_slice() }) |
| } |
| |
| pub fn push_crate(cs: &mut ~[Crate], prefix: uint, p: &Path) { |
| assert!(p.components.len() > prefix); |
| let mut sub = Path(""); |
| for c in p.components.slice(prefix, p.components.len()).iter() { |
| sub = sub.push(*c); |
| } |
| debug!("Will compile crate %s", sub.to_str()); |
| cs.push(Crate::new(&sub)); |
| } |
| |
| /// Infers crates to build. Called only in the case where there |
| /// is no custom build logic |
| pub fn find_crates(&mut self) { |
| use conditions::missing_pkg_files::cond; |
| |
| let prefix = self.start_dir.components.len(); |
| debug!("Matching against %s", self.id.short_name); |
| do os::walk_dir(&self.start_dir) |pth| { |
| let maybe_known_crate_set = match pth.filename() { |
| Some(filename) => match filename { |
| "lib.rs" => Some(&mut self.libs), |
| "main.rs" => Some(&mut self.mains), |
| "test.rs" => Some(&mut self.tests), |
| "bench.rs" => Some(&mut self.benchs), |
| _ => None |
| }, |
| _ => None |
| }; |
| |
| match maybe_known_crate_set { |
| Some(crate_set) => PkgSrc::push_crate(crate_set, prefix, pth), |
| None => () |
| } |
| true |
| }; |
| |
| let crate_sets = [&self.libs, &self.mains, &self.tests, &self.benchs]; |
| if crate_sets.iter().all(|crate_set| crate_set.is_empty()) { |
| |
| note("Couldn't infer any crates to build.\n\ |
| Try naming a crate `main.rs`, `lib.rs`, \ |
| `test.rs`, or `bench.rs`."); |
| cond.raise(self.id.clone()); |
| } |
| |
| debug!("In %s, found %u libs, %u mains, %u tests, %u benchs", |
| self.start_dir.to_str(), |
| self.libs.len(), |
| self.mains.len(), |
| self.tests.len(), |
| self.benchs.len()) |
| } |
| |
| fn build_crates(&self, |
| ctx: &BuildContext, |
| destination_dir: &Path, |
| crates: &[Crate], |
| cfgs: &[~str], |
| what: OutputType) { |
| for crate in crates.iter() { |
| let path = self.start_dir.push_rel(&crate.file).normalize(); |
| debug!("build_crates: compiling %s", path.to_str()); |
| let path_str = path.to_str(); |
| let cfgs = crate.cfgs + cfgs; |
| |
| do ctx.workcache_context.with_prep(crate_tag(&path)) |prep| { |
| debug!("Building crate %s, declaring it as an input", path.to_str()); |
| prep.declare_input("file", path.to_str(), |
| workcache_support::digest_file_with_date(&path)); |
| let subpath = path.clone(); |
| let subcfgs = cfgs.clone(); |
| let subpath_str = path_str.clone(); |
| let subcx = ctx.clone(); |
| let id = self.id.clone(); |
| let sub_dir = destination_dir.clone(); |
| let sub_flags = crate.flags.clone(); |
| do prep.exec |exec| { |
| let result = compile_crate(&subcx, |
| exec, |
| &id, |
| &subpath, |
| &sub_dir, |
| sub_flags, |
| subcfgs, |
| false, |
| what).to_str(); |
| debug!("Result of compiling %s was %s", subpath_str, result); |
| result |
| } |
| }; |
| } |
| } |
| |
| /// Declare all the crate files in the package source as inputs |
| /// (to the package) |
| pub fn declare_inputs(&self, prep: &mut workcache::Prep) { |
| let to_do = ~[self.libs.clone(), self.mains.clone(), |
| self.tests.clone(), self.benchs.clone()]; |
| debug!("In declare inputs, self = %s", self.to_str()); |
| for cs in to_do.iter() { |
| for c in cs.iter() { |
| let path = self.start_dir.push_rel(&c.file).normalize(); |
| debug!("Declaring input: %s", path.to_str()); |
| prep.declare_input("file", |
| path.to_str(), |
| workcache_support::digest_file_with_date(&path.clone())); |
| } |
| } |
| } |
| |
| // It would be better if build returned a Path, but then Path would have to derive |
| // Encodable. |
| pub fn build(&self, |
| build_context: &BuildContext, |
| cfgs: ~[~str]) -> ~str { |
| use conditions::not_a_workspace::cond; |
| |
| // Determine the destination workspace (which depends on whether |
| // we're using the rust_path_hack) |
| let destination_workspace = if is_workspace(&self.workspace) { |
| debug!("%s is indeed a workspace", self.workspace.to_str()); |
| self.workspace.clone() |
| } else { |
| // It would be nice to have only one place in the code that checks |
| // for the use_rust_path_hack flag... |
| if build_context.context.use_rust_path_hack { |
| let rs = default_workspace(); |
| debug!("Using hack: %s", rs.to_str()); |
| rs |
| } else { |
| cond.raise(fmt!("Package root %s is not a workspace; pass in --rust_path_hack \ |
| if you want to treat it as a package source", |
| self.workspace.to_str())) |
| } |
| }; |
| |
| let libs = self.libs.clone(); |
| let mains = self.mains.clone(); |
| let tests = self.tests.clone(); |
| let benchs = self.benchs.clone(); |
| debug!("Building libs in %s, destination = %s", |
| destination_workspace.to_str(), destination_workspace.to_str()); |
| self.build_crates(build_context, &destination_workspace, libs, cfgs, Lib); |
| debug!("Building mains"); |
| self.build_crates(build_context, &destination_workspace, mains, cfgs, Main); |
| debug!("Building tests"); |
| self.build_crates(build_context, &destination_workspace, tests, cfgs, Test); |
| debug!("Building benches"); |
| self.build_crates(build_context, &destination_workspace, benchs, cfgs, Bench); |
| destination_workspace.to_str() |
| } |
| |
| /// Debugging |
| pub fn dump_crates(&self) { |
| let crate_sets = [&self.libs, &self.mains, &self.tests, &self.benchs]; |
| for crate_set in crate_sets.iter() { |
| for c in crate_set.iter() { |
| debug!("Built crate: %s", c.file.to_str()) |
| } |
| } |
| } |
| } |
