Merge pull request #2 from tablelandnetwork/carson/hamt

Basic Objectstore Actor with S3-inspired API and basic tests

Author: sanderpick

Cargo.lock

@@ -17,14 +17,20 @@ fil_actors_runtime = { workspace = true, optional = true, features = [
 fvm_shared = { workspace = true }
 fvm_ipld_encoding = { workspace = true }
 fvm_ipld_blockstore = { workspace = true }
-fvm_ipld_kamt = { workspace = true }
+fvm_ipld_hamt = { workspace = true }
 num-derive = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_tuple = { workspace = true }
 num-traits = { workspace = true }
 frc42_dispatch = { workspace = true }
 anyhow = { workspace = true }
 
+[dev-dependencies]
+fil_actors_runtime = { workspace = true, features = [
+    "test_utils",
+    "fil-actor",
+] }
+
 [features]
 default = []
 fil-actor = ["fil_actors_runtime"]

fendermint/actors/objectstore/Cargo.toml

@@ -1,3 +1,4 @@
+// Copyright 2024 Textile Inc
 // Copyright 2021-2023 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
 
@@ -7,68 +8,88 @@ use fil_actors_runtime::builtin::singletons::SYSTEM_ACTOR_ADDR;
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
 use fil_actors_runtime::ActorDowncast;
 use fil_actors_runtime::ActorError;
+use fvm_ipld_hamt::BytesKey;
 use fvm_shared::error::ExitCode;
 
-use crate::{ConstructorParams, Method, State, OBJECTSTORE_ACTOR_NAME};
+use crate::DeleteObjectParams;
+use crate::{Method, PutObjectParams, State, OBJECTSTORE_ACTOR_NAME};
 
 fil_actors_runtime::wasm_trampoline!(Actor);
 
 pub struct Actor;
 
 impl Actor {
-    fn constructor(rt: &impl Runtime, params: ConstructorParams) -> Result<(), ActorError> {
-        // Note(sander): We're setting this up to be a subnet-wide actor for a single repo.
-        // Note(sander): In the future, this could be deployed dynamically for multi repo subnets.
+    fn constructor(rt: &impl Runtime) -> Result<(), ActorError> {
+        // FIXME:(sander) We're setting this up to be a subnet-wide actor for a single repo.
+        // FIXME:(sander) In the future, this could be deployed dynamically for multi repo subnets.
         rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
 
         let state = State::new(rt.store()).map_err(|e| {
-            e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to create empty KAMT")
+            e.downcast_default(
+                ExitCode::USR_ILLEGAL_STATE,
+                "failed to construct empty store",
+            )
         })?;
 
-        rt.create(&state)?;
+        rt.create(&state)
+    }
+
+    fn append_object(rt: &impl Runtime, params: PutObjectParams) -> Result<(), ActorError> {
+        // FIXME:(carsonfarmer) We'll want to validate the caller is the owner of the repo.
+        rt.validate_immediate_caller_accept_any()?;
+
+        rt.transaction(|st: &mut State, rt| {
+            st.append(rt.store(), BytesKey(params.key), params.content)
+                .map_err(|e| {
+                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to append to object")
+                })
+        })?;
+
+        Ok(())
+    }
+
+    fn put_object(rt: &impl Runtime, params: PutObjectParams) -> Result<(), ActorError> {
+        // FIXME:(carsonfarmer) We'll want to validate the caller is the owner of the repo.
+        rt.validate_immediate_caller_accept_any()?;
+
+        rt.transaction(|st: &mut State, rt| {
+            st.put(rt.store(), BytesKey(params.key), params.content)
+                .map_err(|e| {
+                    e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to put object")
+                })
+        })?;
+
+        Ok(())
+    }
+
+    fn delete_object(rt: &impl Runtime, params: DeleteObjectParams) -> Result<(), ActorError> {
+        // FIXME:(carsonfarmer) We'll want to validate the caller is the owner of the repo.
+        rt.validate_immediate_caller_accept_any()?;
+
+        rt.transaction(|st: &mut State, rt| {
+            st.delete(rt.store(), &BytesKey(params.key)).map_err(|e| {
+                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to delete to object")
+            })
+        })?;
 
         Ok(())
     }
 
-    // Note(sander): Probably obvious, but example actor method that mutates state
-    // fn push_block_hash(rt: &impl Runtime, params: PushBlockParams) -> Result<(), ActorError> {
-    //     rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
-    //
-    //     rt.transaction(|st: &mut State, rt| {
-    //         // load the blockhashes AMT
-    //         let mut blockhashes = Array::load(&st.blockhashes, rt.store()).map_err(|e| {
-    //             e.downcast_default(
-    //                 ExitCode::USR_ILLEGAL_STATE,
-    //                 "failed to load blockhashes states",
-    //             )
-    //         })?;
-    //
-    //         // push the block to the AMT
-    //         blockhashes.set(params.epoch as u64, params.block).unwrap();
-    //
-    //         // remove the oldest block if the AMT is full (note that this assume the
-    //         // for_each_while iterates in order, which it seems to do)
-    //         if blockhashes.count() > st.lookback_len {
-    //             let mut first_idx = 0;
-    //             blockhashes
-    //                 .for_each_while(|i, _: &BlockHash| {
-    //                     first_idx = i;
-    //                     Ok(false)
-    //                 })
-    //                 .unwrap();
-    //             blockhashes.delete(first_idx).unwrap();
-    //         }
-    //
-    //         // save the new blockhashes AMT cid root
-    //         st.blockhashes = blockhashes.flush().map_err(|e| {
-    //             e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to save blockhashes")
-    //         })?;
-    //
-    //         Ok(())
-    //     })?;
-    //
-    //     Ok(())
-    // }
+    fn get_object(rt: &impl Runtime, key: Vec<u8>) -> Result<Option<Vec<u8>>, ActorError> {
+        let st: State = rt.state()?;
+
+        st.get(rt.store(), &BytesKey(key))
+            .map_err(|e| e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to get object"))
+    }
+
+    fn list_objects(rt: &impl Runtime) -> Result<Option<Vec<Vec<u8>>>, ActorError> {
+        let st: State = rt.state()?;
+
+        let objects = st.list(rt.store()).map_err(|e| {
+            e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to list objects")
+        })?;
+        Ok(Some(objects))
+    }
 }
 
 impl ActorCode for Actor {
@@ -80,8 +101,10 @@ impl ActorCode for Actor {
 
     actor_dispatch! {
         Constructor => constructor,
-        // PushBlockHash => push_block_hash,
-        // LookbackLen => lookback_len,
-        // GetBlockHash => get_block_hash,
+        PutObject => put_object,
+        AppendObject => append_object,
+        DeleteObject => delete_object,
+        GetObject => get_object,
+        ListObjects => list_objects,
     }
 }

fendermint/actors/objectstore/src/actor.rs

@@ -1,5 +1,7 @@
+// Copyright 2024 Textile Inc
 // Copyright 2021-2023 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
+
 #[cfg(feature = "fil-actor")]
 mod actor;
 mod shared;