Using user cache instead of local dir

Author: mbillingr

Cargo.toml

@@ -7,6 +7,7 @@ authors = ["Martin Billinger <flkazemakase@gmail.com>"]
 simple_logger = "0.5"
 
 [dependencies]
+app_dirs = "1.2.1"
 arff = { path = "../arff" }
 fs2 = "*"
 futures = "0.1"

src/error.rs

@@ -2,6 +2,7 @@ use std::io::Error as IoError;
 use std::result::Result as StdResult;
 use std::string::FromUtf8Error;
 
+use app_dirs::AppDirsError;
 use arff::Error as ArffError;
 use hyper::Error as HyperError;
 use hyper::error::UriError;
@@ -19,6 +20,7 @@ pub enum Error {
     HyperTlsError(TlsError),
     JsonError(JsonError),
     ArffError(ArffError),
+    AppDirsError(AppDirsError),
 }
 
 impl From<IoError> for Error {
@@ -62,3 +64,12 @@ impl From<ArffError> for Error {
         Error::ArffError(e)
     }
 }
+
+impl From<AppDirsError> for Error {
+    fn from(e: AppDirsError) -> Self {
+        match e {
+            AppDirsError::Io(e) => Error::IoError(e),
+            _ => Error::AppDirsError(e)
+        }
+    }
+}

src/lib.rs

@@ -1,3 +1,4 @@
+extern crate app_dirs;
 extern crate arff;
 extern crate fs2;
 extern crate futures;

src/openml_api/web_access.rs

@@ -1,7 +1,7 @@
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read, Write};
-use std::path::Path;
 
+use app_dirs::{app_root, AppDataType, AppInfo};
 use futures::{Future, Stream};
 use hyper::Client;
 use hyper_tls::HttpsConnector;
@@ -11,14 +11,19 @@ use error::Result;
 
 use super::file_lock::{ExclusiveLock, SharedLock};
 
+const APP_INFO: AppInfo = AppInfo{name: "openml-rust", author: "openml-rust"};
+
 pub fn get_cached(url: &str) -> Result<String> {
     // todo: is there a potential race condition with a process locking the file for reading while
     //       the writer has created but not yet locked the file?
-    let filename = "cache/".to_owned() + &url_to_file(url);
-    let path = Path::new(&filename);
+
+    let mut path = app_root(AppDataType::UserCache, &APP_INFO)?;
+    path.push(url_to_file(url));
+
+    println!("{:?}", path);
 
     loop {
-        match File::open(path) {
+        match File::open(&path) {
             Ok(f) => {
                 info!("Loading cached {}", url);
                 let mut file = SharedLock::new(f)?;
@@ -29,7 +34,7 @@ pub fn get_cached(url: &str) -> Result<String> {
             Err(_) => {}
         }
 
-        match OpenOptions::new().create_new(true).write(true).open(path) {
+        match OpenOptions::new().create_new(true).write(true).open(&path) {
             Err(e) => {
                 // todo: is this the correct io error raised if another thread has locked the file currently?
                 if let io::ErrorKind::PermissionDenied = e.kind() {