Merge branch 'fix-bm-remove'

src/module/bm/commands.rs

@@ -60,8 +60,14 @@ pub fn remove_command(module: &Module, env: CommandEnv) -> CommandResult {
         debug!("Remove by id: {}", id);
 
         let parser = Parser::new(JsonHeaderParser::new(None));
-        let file   = env.bk.get_file_by_id(module, &id.into(), &parser).unwrap();
+        let file = env.bk
-        debug!("Remove file  : {:?}", file);
+            .get_file_by_id(module, &id.into(), &parser)
+            .unwrap_or({
+                info!("No files found");
+                return Ok(())
+            });
+
+        debug!("Remove file: {:?}", file);
 
         if let Err(e) = env.bk.remove_file(module, file, checked) {
             debug!("Remove failed");
@@ -69,7 +75,7 @@ pub fn remove_command(module: &Module, env: CommandEnv) -> CommandResult {
             err.caused_by = Some(Box::new(e));
             Err(err)
         } else {
-            debug!("Remove worked");
+            info!("Remove worked");
             Ok(())
         }
     } else {

src/storage/backend.rs

@@ -59,10 +59,7 @@ impl StorageBackend {
         glob(&globstr[..])
             .and_then(|globlist| {
                 debug!("Iterating over globlist");
-                Ok(globlist.filter_map(Result::ok)
+                Ok(globlist_to_file_id_vec(globlist).into_iter())
-                           .map(|pbuf| FileID::from(&pbuf))
-                           .collect::<Vec<FileID>>()
-                           .into_iter())
             })
             .map_err(|e| {
                 debug!("glob() returned error: {:?}", e);
@@ -189,16 +186,41 @@ impl StorageBackend {
     pub fn get_file_by_id<'a, HP>(&self, m: &'a Module, id: &FileID, p: &Parser<HP>) -> Option<File<'a>>
         where HP: FileHeaderParser
     {
+        use std::ops::Index;
+
         debug!("Searching for file with id '{}'", id);
-        if let Ok(mut fs) = FSFile::open(self.build_filepath_with_id(m, id.clone())) {
+
-            let mut s = String::new();
+        if id.get_type() == FileIDType::NONE {
-            fs.read_to_string(&mut s);
+            // We don't know the hash type, so we glob() around a bit.
-            debug!("Success opening file with id '{}'", id);
+            debug!("Having FileIDType::NONE, so we glob() for the raw ID");
-            debug!("Parsing to internal structure now");
+
-            p.read(s).and_then(|(h, d)| Ok(File::from_parser_result(m, id.clone(), h, d))).ok()
+            let id_str = id.get_id().unwrap_or(String::from("INVALID"));
+            let globstr = self.prefix_of_files_for_module(m) + "*" + &id_str[..] + ".imag";
+            debug!("Globbing with globstr = '{}'", globstr);
+            glob(&globstr[..]).map(|globlist| {
+                let mut vec = globlist_to_file_id_vec(globlist).into_iter()
+                                .filter_map(|id| self.get_file_by_id(m, &id, p))
+                                .collect::<Vec<File>>();
+                vec.reverse();
+                vec.pop()
+            }).unwrap_or({
+                debug!("No glob matches, actually. We can't do anything at this point");
+                None
+            })
         } else {
-            debug!("No file with id '{}'", id);
+            // The (hash)type is already in the FileID object, so we can just
-            None
+            // build a path from the information we already have
+            debug!("We know FileIDType, so we build the path directly now");
+            if let Ok(mut fs) = FSFile::open(self.build_filepath_with_id(m, id.clone())) {
+                let mut s = String::new();
+                fs.read_to_string(&mut s);
+                debug!("Success opening file with id '{}'", id);
+                debug!("Parsing to internal structure now");
+                p.read(s).and_then(|(h, d)| Ok(File::from_parser_result(m, id.clone(), h, d))).ok()
+            } else {
+                debug!("No file with id '{}'", id);
+                None
+            }
         }
     }
 
@@ -307,3 +329,9 @@ fn write_with_parser<'a, HP>(f: &File, p: &Parser<HP>) -> Result<String, Storage
             Err(serr)
         })
 }
+
+fn globlist_to_file_id_vec(globlist: Paths) -> Vec<FileID> {
+    globlist.filter_map(Result::ok)
+            .map(|pbuf| FileID::from(&pbuf))
+            .collect::<Vec<FileID>>()
+}

src/storage/file_id.rs

@@ -73,6 +73,10 @@ impl FileID {
         self.id_type.clone()
     }
 
+    pub fn get_id(&self) -> Option<String> {
+        self.id.clone()
+    }
+
 }
 
 impl Debug for FileID {
@@ -127,7 +131,7 @@ impl From<String> for FileID {
 impl<'a> From<&'a String> for FileID {
 
     fn from(string: &'a String) -> FileID {
-
+        // we assume that it is an path
         let regex = Regex::new(r"([:alnum:]*)-([:upper:]*)-([A-Za-z0-9-_]*)\.(.*)").unwrap();
         let s = string.split("/").last().unwrap_or("");
 
@@ -160,9 +164,10 @@ impl<'a> From<&'a String> for FileID {
             Some(FileID::new(idtype, String::from(hash)))
         }).unwrap_or({
             debug!("Did not match");
+            debug!("It is no path, actually. So we assume it is an ID already");
             FileID {
                 id_type: FileIDType::NONE,
-                id: None,
+                id: Some(string.clone()),
             }
         })
     }