bldr upload now uploads dependencies

This fixes bldr upload to now correctly deal with dependencies.

* If a dependency doesn't exist in the depot, we check for an archive in
  the same directory as the archive you specified on the command line,
  and upload it
* If everything is present, it doesn't upload anything

components/bldr/src/command/upload.rs

@@ -41,8 +41,57 @@ static LOGKEY: &'static str = "CU";
 /// * Fails if it cannot upload the file
 pub fn package(config: &Config) -> BldrResult<()> {
     let url = config.url().as_ref().unwrap();
+    let mut archive_path = PathBuf::from(config.archive().clone());
+    archive_path.pop();
     let mut pa = PackageArchive::new(PathBuf::from(config.archive()));
-    outputln!("Uploading from {}", pa.path.to_string_lossy());
+    outputln!("Checking that all dependencies are in the depot...");
+    let tdeps = try!(pa.tdeps());
+    for dep in tdeps.iter() {
+        match depot::client::show_package(url, dep) {
+            Ok(_) => outputln!("{} is present", dep),
+            Err(BldrError{ err: ErrorKind::RemotePackageNotFound(_), .. }) => {
+                let dep_path = PathBuf::from(format!("{}/{}",
+                                                     archive_path.to_string_lossy(),
+                                                     dep.archive_name().unwrap()));
+                if dep_path.is_file() {
+                    outputln!("Uploading {} from {}", dep, dep_path.to_string_lossy());
+                    let mut dpa = PackageArchive::new(dep_path);
+                    match upload(&mut dpa, &url) {
+                        Ok(()) => {}
+                        Err(e @ BldrError{ err: ErrorKind::HTTP(_), .. }) => return Err(e),
+                        Err(e @ BldrError{ err: ErrorKind::PackageArchiveMalformed(_), .. }) => {
+                            return Err(e)
+                        }
+                        Err(_) => {
+                            // This is because of a bug where the depot and client code seem to not
+                            // correctly deal with conflicts.
+                            outputln!("Trying the next package anyway...");
+                        }
+                    }
+                } else {
+                    outputln!("Cannot find an archive for {} at {}",
+                              dep.archive_name().unwrap(),
+                              archive_path.to_string_lossy());
+                    return Err(bldr_error!(ErrorKind::FileNotFound(archive_path.to_string_lossy()
+                                                                           .into_owned())));
+                }
+            }
+            Err(e) => return Err(e),
+        }
+    }
+    let ident = try!(pa.ident());
+    match depot::client::show_package(url, &ident) {
+        Ok(_) => outputln!("{} is present", ident),
+        Err(_) => {
+            outputln!("Uploading {} from {}", ident, pa.path.to_string_lossy());
+            try!(upload(&mut pa, &url));
+            outputln!("Complete");
+        }
+    }
+    Ok(())
+}
+
+pub fn upload(mut pa: &mut PackageArchive, url: &str) -> BldrResult<()> {
     match depot::client::put_package(url, &mut pa) {
         Ok(()) => (),
         Err(BldrError{err: ErrorKind::HTTP(StatusCode::Conflict), ..}) => {
@@ -60,6 +109,5 @@ pub fn package(config: &Config) -> BldrResult<()> {
             return Err(e);
         }
     }
-    outputln!("Complete");
     Ok(())
 }

components/bldr/src/package/mod.rs

@@ -76,6 +76,18 @@ impl PackageIdent {
         }
     }
 
+    pub fn archive_name(&self) -> Option<String> {
+        if self.fully_qualified() {
+            Some(format!("{}-{}-{}-{}.bldr",
+                         self.origin,
+                         self.name,
+                         self.version.as_ref().unwrap(),
+                         self.release.as_ref().unwrap()))
+        } else {
+            None
+        }
+    }
+
     pub fn fully_qualified(&self) -> bool {
         self.version.is_some() && self.release.is_some()
     }