rustpkg: Use workcache

rustpkg now uses the workcache library to avoid recompilation.
Hooray!

Author: catamorphism

src/libextra/workcache.rs

@@ -493,15 +493,20 @@ impl<'self, T:Send +
 #[test]
 fn test() {
     use std::io::WriterUtil;
-    use std::run;
+    use std::{os, run};
 
     let pth = Path("foo.c");
     {
         let r = io::file_writer(&pth, [io::Create]);
         r.unwrap().write_str("int main() { return 0; }");
     }
 
-    let cx = Context::new(RWArc::new(Database::new(Path("db.json"))),
+    let db_path = os::self_exe_path().expect("workcache::test failed").pop().push("db.json");
+    if os::path_exists(&db_path) {
+        os::remove_file(&db_path);
+    }
+
+    let cx = Context::new(RWArc::new(Database::new(db_path)),
                           RWArc::new(Logger::new()),
                           Arc::new(TreeMap::new()));
 

src/librustpkg/api.rs

@@ -13,49 +13,101 @@ use crate::*;
 use package_id::*;
 use package_source::*;
 use version::Version;
+use workcache_support::*;
 
+use extra::arc::{Arc,RWArc};
+use extra::workcache;
+use extra::workcache::*;
 use std::os;
-use std::hashmap::*;
+use extra::treemap::TreeMap;
 
 /// Convenience functions intended for calling from pkg.rs
+/// p is where to put the cache file for dependencies
+pub fn default_ctxt(p: Path) -> BuildCtx {
+    new_default_ctx(new_workcache_cx(&p), p)
+}
 
-fn default_ctxt(p: @Path) -> Ctx {
-    Ctx {
-        use_rust_path_hack: false,
-        sysroot_opt: Some(p),
-        json: false,
-        dep_cache: @mut HashMap::new()
+pub fn new_default_ctx(c: Context, p: Path) -> BuildCtx {
+    BuildCtx {
+        cx: Ctx { use_rust_path_hack: false,
+                  sysroot_opt: p },
+        workcache_cx: c
     }
 }
 
-pub fn build_lib(sysroot: @Path, root: Path, name: ~str, version: Version,
-                 lib: Path) {
+fn file_is_fresh(path: &str, in_hash: &str) -> bool {
+    in_hash == digest_file_with_date(&Path(path))
+}
 
-    let pkg_src = PkgSrc {
-        root: root,
-        id: PkgId{ version: version, ..PkgId::new(name)},
-        libs: ~[mk_crate(lib)],
-        mains: ~[],
-        tests: ~[],
-        benchs: ~[]
-    };
-    pkg_src.build(&default_ctxt(sysroot), ~[]);
+fn binary_is_fresh(path: &str, in_hash: &str) -> bool {
+    in_hash == digest_only_date(&Path(path))
 }
 
-pub fn build_exe(sysroot: @Path, root: Path, name: ~str, version: Version, main: Path) {
-    let pkg_src = PkgSrc {
-        root: root,
-        id: PkgId{ version: version, ..PkgId::new(name)},
-        libs: ~[],
-        mains: ~[mk_crate(main)],
-        tests: ~[],
-        benchs: ~[]
+
+pub fn new_workcache_cx(p: &Path) -> Context {
+    let db_file = p.push("rustpkg_db.json"); // ??? probably wrong
+    debug!("Workcache database file: %s", db_file.to_str());
+    let db = RWArc::new(Database::new(db_file));
+    let lg = RWArc::new(Logger::new());
+    let cfg = Arc::new(TreeMap::new());
+    let mut rslt: FreshnessMap = TreeMap::new();
+    // Set up freshness functions for every type of dependency rustpkg
+    // knows about
+    rslt.insert(~"file", file_is_fresh);
+    rslt.insert(~"binary", binary_is_fresh);
+    workcache::Context::new_with_freshness(db, lg, cfg, Arc::new(rslt))
+}
+
+pub fn build_lib(sysroot: Path, root: Path, name: ~str, version: Version,
+                 lib: Path) {
+    let cx = default_ctxt(sysroot);
+    let subroot = root.clone();
+    let subversion = version.clone();
+    let sublib = lib.clone();
+    do cx.workcache_cx.with_prep(name) |prep| {
+        let pkg_src = PkgSrc {
+            workspace: subroot.clone(),
+            start_dir: subroot.push("src").push(name),
+            id: PkgId{ version: subversion.clone(), ..PkgId::new(name)},
+            libs: ~[mk_crate(sublib.clone())],
+            mains: ~[],
+            tests: ~[],
+            benchs: ~[]
+        };
+        pkg_src.declare_inputs(prep);
+        let subcx = cx.clone();
+        let subsrc = pkg_src.clone();
+        do prep.exec |exec| {
+            subsrc.clone().build(exec, &subcx.clone(), ~[]);
+        }
     };
-    pkg_src.build(&default_ctxt(sysroot), ~[]);
+}
 
+pub fn build_exe(sysroot: Path, root: Path, name: ~str, version: Version,
+                 main: Path) {
+    let cx = default_ctxt(sysroot);
+    let subroot = root.clone();
+    let submain = main.clone();
+    do cx.workcache_cx.with_prep(name) |prep| {
+        let pkg_src = PkgSrc {
+            workspace: subroot.clone(),
+            start_dir: subroot.push("src").push(name),
+            id: PkgId{ version: version.clone(), ..PkgId::new(name)},
+            libs: ~[],
+            mains: ~[mk_crate(submain.clone())],
+            tests: ~[],
+            benchs: ~[]
+        };
+        pkg_src.declare_inputs(prep);
+        let subsrc = pkg_src.clone();
+        let subcx = cx.clone();
+        do prep.exec |exec| {
+            subsrc.clone().build(exec, &subcx.clone(), ~[]);
+        }
+    }
 }
 
-pub fn install_lib(sysroot: @Path,
+pub fn install_lib(sysroot: Path,
                    workspace: Path,
                    name: ~str,
                    lib_path: Path,
@@ -65,23 +117,33 @@ pub fn install_lib(sysroot: @Path,
     debug!("workspace = %s", workspace.to_str());
     // make a PkgSrc
     let pkg_id = PkgId{ version: version, ..PkgId::new(name)};
-    let pkg_src = PkgSrc {
-        root: workspace.clone(),
-        id: pkg_id.clone(),
-        libs: ~[mk_crate(lib_path)],
-        mains: ~[],
-        tests: ~[],
-        benchs: ~[]
-    };
     let cx = default_ctxt(sysroot);
-    pkg_src.build(&cx, ~[]);
+    let subpath = lib_path.clone();
+    do cx.workcache_cx.with_prep(pkg_id.to_str()) |prep| {
+        let pkg_src = PkgSrc {
+            workspace: workspace.clone(),
+            start_dir: subpath.push("src").push(name),
+            id: pkg_id.clone(),
+            libs: ~[mk_crate(subpath.clone())],
+            mains: ~[],
+            tests: ~[],
+            benchs: ~[]
+        };
+        pkg_src.declare_inputs(prep);
+        let subcx = cx.clone();
+        let subpkg_src = pkg_src.clone();
+        do prep.exec |exec| {
+            subpkg_src.clone().build(exec, &subcx.clone(), ~[]);
+        }
+    }
     cx.install_no_build(&workspace, &pkg_id);
 }
 
-pub fn install_exe(sysroot: @Path, workspace: Path, name: ~str, version: Version) {
-    default_ctxt(sysroot).install(&workspace, &PkgId{ version: version,
-                                            ..PkgId::new(name)});
-
+pub fn install_exe(sysroot: Path, workspace: Path, name: ~str, version: Version) {
+    let cx = default_ctxt(sysroot);
+    debug!("install_exe calling with_prep");
+    let pkgid = PkgId{ version: version, ..PkgId::new(name)};
+    cx.install(PkgSrc::new(workspace, false, pkgid));
 }
 
 fn mk_crate(p: Path) -> Crate {

src/librustpkg/conditions.rs

@@ -12,11 +12,17 @@
 
 pub use std::path::Path;
 pub use package_id::PkgId;
+pub use std::libc;
+pub use std::libc::stat;
 
 condition! {
     pub bad_path: (Path, ~str) -> Path;
 }
 
+condition! {
+    pub bad_stat: (Path, ~str) -> stat;
+}
+
 condition! {
     pub nonexistent_package: (PkgId, ~str) -> Path;
 }

src/librustpkg/context.rs

@@ -10,56 +10,66 @@
 
 // Context data structure used by rustpkg
 
-
-use std::hashmap::HashMap;
 use std::os;
+use extra::workcache;
 
+#[deriving(Clone)]
 pub struct Ctx {
     // If use_rust_path_hack is true, rustpkg searches for sources
     // in *package* directories that are in the RUST_PATH (for example,
     // FOO/src/bar-0.1 instead of FOO). The flag doesn't affect where
     // rustpkg stores build artifacts.
     use_rust_path_hack: bool,
-    // Sysroot -- if this is None, uses rustc filesearch's
-    // idea of the default
-    sysroot_opt: Option<@Path>,
-    // I'm not sure what this is for
-    json: bool,
-    // Cache of hashes of things already installed
-    // though I'm not sure why the value is a bool
-    dep_cache: @mut HashMap<~str, bool>,
+    // The root directory containing the Rust standard libraries
+    sysroot_opt: Path
+}
+
+#[deriving(Clone)]
+pub struct BuildCtx {
+    // Context for workcache
+    workcache_cx: workcache::Context,
+    // Everything else
+    cx: Ctx
+}
+
+impl BuildCtx {
+    pub fn sysroot_opt(&self) -> Path {
+        self.cx.sysroot_opt.clone()
+    }
+
+    pub fn sysroot_to_use(&self) -> Path {
+        self.cx.sysroot_to_use()
+    }
+}
+
+impl Ctx {
+    pub fn sysroot_opt(&self) -> Path {
+        self.sysroot_opt.clone()
+    }
 }
 
 impl Ctx {
     /// Debugging
     pub fn sysroot_opt_str(&self) -> ~str {
-        match self.sysroot_opt {
-            None => ~"[none]",
-            Some(p) => p.to_str()
-        }
+        self.sysroot_opt.to_str()
     }
 
     // Hack so that rustpkg can run either out of a rustc target dir,
     // or the host dir
-    pub fn sysroot_to_use(&self) -> Option<@Path> {
-        if !in_target(self.sysroot_opt) {
-            self.sysroot_opt
+    pub fn sysroot_to_use(&self) -> Path {
+        if !in_target(&self.sysroot_opt) {
+            self.sysroot_opt.clone()
         }
         else {
-            self.sysroot_opt.map(|p| { @p.pop().pop().pop() })
+            self.sysroot_opt.pop().pop().pop()
         }
-    }
+  }
 }
 
 /// We assume that if ../../rustc exists, then we're running
 /// rustpkg from a Rust target directory. This is part of a
 /// kludgy hack used to adjust the sysroot.
-pub fn in_target(sysroot_opt: Option<@Path>) -> bool {
-    match sysroot_opt {
-        None => false,
-        Some(p) => {
-            debug!("Checking whether %s is in target", p.to_str());
-            os::path_is_dir(&p.pop().pop().push("rustc"))
-        }
-    }
+pub fn in_target(sysroot_opt: &Path) -> bool {
+    debug!("Checking whether %s is in target", sysroot_opt.to_str());
+    os::path_is_dir(&sysroot_opt.pop().pop().push("rustc"))
 }

src/librustpkg/package_id.rs

@@ -51,12 +51,10 @@ impl PkgId {
         // Did the user request a specific version?
         let s = match split_version(s) {
             Some((path, v)) => {
-                debug!("s = %s, path = %s, v = %s", s, path, v.to_str());
                 given_version = Some(v);
                 path
             }
             None => {
-                debug!("%s has no explicit version", s);
                 s
             }
         };
@@ -81,7 +79,6 @@ impl PkgId {
             }
         };
 
-        debug!("path = %s", path.to_str());
         PkgId {
             path: path.clone(),
             short_name: short_name.to_owned(),