Add support for Android

Android doesn't support hard_link so provide an alternate path for
performing the requested operation.

This also fixes a bug where failed put might result in the staged file
being left around.

Author: vlovich

Cargo.toml

@@ -61,6 +61,9 @@ serde_json = { version = "1.0", default-features = false, features = ["std"], op
 serde_urlencoded = { version = "0.7", optional = true }
 tokio = { version = "1.29.0", features = ["sync", "macros", "rt", "time", "io-util"] }
 
+[target.'cfg(target_os="android")'.dependencies]
+nix = { version = "0.30.0", features = ["fs"] }
+
 [target.'cfg(target_family="unix")'.dev-dependencies]
 nix = { version = "0.30.0", features = ["fs"] }
 

src/local.rs

@@ -351,22 +351,38 @@ impl ObjectStore for LocalFileSystem {
                             std::mem::drop(file);
                             match std::fs::rename(&staging_path, &path) {
                                 Ok(_) => None,
-                                Err(source) => Some(Error::UnableToRenameFile { source }),
+                                Err(source) => {
+                                    let _ = std::fs::remove_file(&staging_path);
+                                    Some(Error::UnableToRenameFile { source })
+                                },
                             }
                         }
-                        PutMode::Create => match std::fs::hard_link(&staging_path, &path) {
-                            Ok(_) => {
-                                let _ = std::fs::remove_file(&staging_path); // Attempt to cleanup
-                                None
+                        PutMode::Create => {
+                            #[cfg(not(target_os = "android"))]
+                            let create_result = std::fs::hard_link(&staging_path, &path);
+
+                            #[cfg(target_os = "android")]
+                            let create_result = nix::fcntl::renameat2(
+                                nix::fcntl::AtFlags::AT_FDCWD,
+                                &staged,
+                                nix::fcntl::AtFlags::AT_FDCWD,
+                                &path,
+                                nix::fcntl::RenameFlags::RENAME_NOREPLACE,
+                            );
+
+                            let _ = std::fs::remove_file(&staging_path); // Attempt to cleanup
+
+                            match create_result {
+                                Ok(_) => None,
+                                Err(source) => match source.kind() {
+                                    ErrorKind::AlreadyExists => Some(Error::AlreadyExists {
+                                        path: path.to_str().unwrap().to_string(),
+                                        source,
+                                    }),
+                                    _ => Some(Error::UnableToRenameFile { source }),
+                                },
                             }
-                            Err(source) => match source.kind() {
-                                ErrorKind::AlreadyExists => Some(Error::AlreadyExists {
-                                    path: path.to_str().unwrap().to_string(),
-                                    source,
-                                }),
-                                _ => Some(Error::UnableToRenameFile { source }),
-                            },
-                        },
+                        }
                         PutMode::Update(_) => unreachable!(),
                     }
                 }
@@ -558,7 +574,14 @@ impl ObjectStore for LocalFileSystem {
         // This is necessary because hard_link returns an error if the destination already exists
         maybe_spawn_blocking(move || loop {
             let staged = staged_upload_path(&to, &id.to_string());
-            match std::fs::hard_link(&from, &staged) {
+
+            #[cfg(not(target_os = "android"))]
+            let stage_result = std::fs::hard_link(&from, &staged);
+
+            #[cfg(target_os = "android")]
+            let stage_result = std::fs::copy(&from, &staged);
+
+            match stage_result {
                 Ok(_) => {
                     return std::fs::rename(&staged, &to).map_err(|source| {
                         let _ = std::fs::remove_file(&staged); // Attempt to clean up
@@ -596,6 +619,7 @@ impl ObjectStore for LocalFileSystem {
         .await
     }
 
+    #[cfg(not(target_os = "android"))]
     async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
         let from = self.path_to_filesystem(from)?;
         let to = self.path_to_filesystem(to)?;
@@ -621,6 +645,54 @@ impl ObjectStore for LocalFileSystem {
         })
         .await
     }
+
+    #[cfg(target_os = "android")]
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        let from = self.path_to_filesystem(from)?;
+        let to = self.path_to_filesystem(to)?;
+        let mut id = 0;
+        // In order to make this atomic we:
+        //
+        // - stage to a temporary file
+        // - atomically rename this temporary file into place only if to does not exist
+        //
+        // This is necessary because hard_link is EACCESS on Android.
+        maybe_spawn_blocking(move || loop {
+            let staged = staged_upload_path(&to, &id.to_string());
+
+            match std::fs::copy(&from, &staged) {
+                Ok(_) => {
+                    let rename_result = nix::fcntl::renameat2(
+                        nix::fcntl::AtFlags::AT_FDCWD,
+                        &staged,
+                        nix::fcntl::AtFlags::AT_FDCWD,
+                        &to,
+                        nix::fcntl::RenameFlags::RENAME_NOREPLACE,
+                    );
+                    let _ = std::fs::remove_file(&staged); // Attempt to clean up
+                    return rename_result.map_err(|source| {
+                        if source.kind() == ErrorKind::NotFound {
+                            Error::AlreadyExists {
+                                path: to.to_str().unwrap().to_string(),
+                                source,
+                            }
+                        } else {
+                            Error::UnableToCopyFile { from, to, source }
+                        }
+                    });
+                }
+                Err(source) => match source.kind() {
+                    ErrorKind::AlreadyExists => id += 1,
+                    ErrorKind::NotFound => match from.exists() {
+                        true => create_parent_dirs(&to, source)?,
+                        false => return Err(Error::NotFound { path: from, source }.into()),
+                    },
+                    _ => return Err(Error::UnableToCopyFile { from, to, source }.into()),
+                },
+            }
+        })
+        .await
+    }
 }
 
 impl LocalFileSystem {