Merge branch 'errors-from-backend'

src/module/bm/commands.rs

@@ -39,7 +39,7 @@ pub fn list_command(module: &Module, env: CommandEnv) -> CommandResult {
     let files   = get_filtered_files_from_backend(module, &env);
 
     debug!("Printing files now");
-    printer.print_files(files);
+    files.map(|f| printer.print_files(f));
 
     Ok(())
 }
@@ -66,7 +66,7 @@ pub fn remove_command(module: &Module, env: CommandEnv) -> CommandResult {
     } else {
         debug!("Remove more than one file");
 
-        let files = get_filtered_files_from_backend(module, &env);
+        get_filtered_files_from_backend(module, &env).and_then(|files| {
             let nfiles = files.len();
             info!("Removing {} Files", nfiles);
 
@@ -94,6 +94,7 @@ pub fn remove_command(module: &Module, env: CommandEnv) -> CommandResult {
             } else {
                 Ok(())
             }
+        })
     }
 }
 
@@ -104,12 +105,14 @@ pub fn remove_command(module: &Module, env: CommandEnv) -> CommandResult {
  */
 
 fn get_filtered_files_from_backend<'a>(module: &'a Module,
-                                       env: &CommandEnv) -> IntoIter<File<'a>>
+                                       env: &CommandEnv)
+    -> Result<IntoIter<File<'a>>, ModuleError>
 {
     let parser = Parser::new(JsonHeaderParser::new(None));
     let tags = get_tags(env.rt, env.matches);
     debug!("Tags: {:?}", tags);
-    env.bk.iter_files(module, &parser).and_then(|files| {
+    env.bk.iter_files(module, &parser)
+        .map(|files| {
             let f = files.filter(|file| {
                 if tags.len() != 0 {
                     debug!("Checking tags of: {:?}", file.id());
@@ -124,8 +127,12 @@ fn get_filtered_files_from_backend<'a>(module: &'a Module,
                     .and_then(|r| Some(file.matches_with(&r)))
                     .unwrap_or(true)
             }).collect::<Vec<File>>();
-        Some(f)
+            f.into_iter()
-    }).unwrap_or(Vec::<File>::new()).into_iter()
+        }).map_err(|e| {
+            let mut merr = ModuleError::new("Could not filter files");
+            merr.caused_by = Some(Box::new(e));
+            merr
+        })
 }
 
 fn get_tags<'a>(rt: &Runtime, sub: &ArgMatches<'a, 'a>) -> Vec<String> {

src/storage/backend.rs

@@ -72,26 +72,42 @@ impl StorageBackend {
         }
     }
 
-    pub fn iter_ids(&self, m: &Module) -> Option<IntoIter<FileID>>
+    pub fn iter_ids(&self, m: &Module) -> Result<IntoIter<FileID>, StorageBackendError>
     {
-        glob(&self.prefix_of_files_for_module(m)[..]).and_then(|globlist| {
+        glob(&self.prefix_of_files_for_module(m)[..])
+            .and_then(|globlist| {
                 let v = globlist.filter_map(Result::ok)
                                 .map(|pbuf| FileID::from(&pbuf))
                                 .collect::<Vec<FileID>>()
                                 .into_iter();
                 Ok(v)
-        }).ok()
+            })
+            .map_err(|e| {
+                let serr = StorageBackendError::build(
+                        "iter_ids()",
+                        "Cannot iter on file ids",
+                        None);
+                serr
+            })
     }
 
     pub fn iter_files<'a, HP>(&self, m: &'a Module, p: &Parser<HP>)
-        -> Option<IntoIter<File<'a>>>
+        -> Result<IntoIter<File<'a>>, StorageBackendError>
         where HP: FileHeaderParser
     {
-        self.iter_ids(m).and_then(|ids| {
+        self.iter_ids(m)
-            Some(ids.filter_map(|id| self.get_file_by_id(m, &id, p))
+            .and_then(|ids| {
+                Ok(ids.filter_map(|id| self.get_file_by_id(m, &id, p))
                         .collect::<Vec<File>>()
                         .into_iter())
             })
+            .map_err(|e| {
+                let serr = StorageBackendError::build(
+                        "iter_files()",
+                        "Cannot iter on files",
+                        None);
+                serr
+            })
     }
 
     /*