use super::client::ActorStateClient;
use crate::actor::types::ActorKey;
use crate::error::Result;
use serde::{de::DeserializeOwned, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
pub struct ActorStateManager {
actor_key: ActorKey,
state_client: Arc<ActorStateClient>,
execution_id: String,
versions: Mutex<HashMap<String, String>>,
}
impl ActorStateManager {
pub fn new(
actor_key: ActorKey,
state_client: Arc<ActorStateClient>,
execution_id: String,
) -> Self {
Self {
actor_key,
state_client,
execution_id,
versions: Mutex::new(HashMap::new()),
}
}
pub async fn get<T>(&self, key: &str) -> Result<Option<T>>
where
T: DeserializeOwned,
{
let (value, version) = self
.state_client
.get_state_with_version(
self.actor_key.actor_name(),
self.actor_key.key(),
key,
&self.execution_id,
)
.await?;
if !version.is_empty() {
self.versions
.lock()
.unwrap()
.insert(key.to_string(), version);
}
Ok(value)
}
pub async fn set<T>(&self, key: &str, value: &T) -> Result<()>
where
T: Serialize,
{
let expected_version = self.versions.lock().unwrap().get(key).cloned();
self.state_client
.set_state(
self.actor_key.actor_name(),
self.actor_key.key(),
key,
value,
&self.execution_id,
expected_version.as_deref(),
)
.await
}
pub async fn delete(&self, key: &str) -> Result<bool> {
self.state_client
.delete_state(
self.actor_key.actor_name(),
self.actor_key.key(),
key,
&self.execution_id,
)
.await
}
pub async fn exists(&self, key: &str) -> Result<bool> {
let result: Option<serde_json::Value> = self.get(key).await?;
Ok(result.is_some())
}
pub async fn list(&self, prefix: Option<&str>) -> Result<Vec<String>> {
self.state_client
.list_state_keys(
self.actor_key.actor_name(),
self.actor_key.key(),
&self.execution_id,
prefix,
)
.await
}
pub async fn clear_all(&self) -> Result<()> {
let keys = self.list(None).await?;
for key in keys {
self.delete(&key).await?;
}
Ok(())
}
pub async fn get_many<T>(&self, keys: &[&str]) -> Result<Vec<(String, Option<T>)>>
where
T: DeserializeOwned,
{
let mut results = Vec::with_capacity(keys.len());
for &key in keys {
let value = self.get(key).await?;
results.push((key.to_string(), value));
}
Ok(results)
}
pub async fn update<T, F>(&self, key: &str, f: F) -> Result<T>
where
T: Serialize + DeserializeOwned,
F: FnOnce(Option<T>) -> T,
{
let current = self.get(key).await?;
let new_value = f(current);
self.set(key, &new_value).await?;
Ok(new_value)
}
pub fn actor_name(&self) -> &str {
self.actor_key.actor_name()
}
pub fn key(&self) -> &str {
self.actor_key.key()
}
pub fn execution_id(&self) -> &str {
&self.execution_id
}
pub fn actor_key(&self) -> &ActorKey {
&self.actor_key
}
}
impl Clone for ActorStateManager {
fn clone(&self) -> Self {
Self {
actor_key: self.actor_key.clone(),
state_client: self.state_client.clone(),
execution_id: self.execution_id.clone(),
versions: Mutex::new(self.versions.lock().unwrap().clone()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::actor::state::ActorStateClientConfig;
#[tokio::test]
#[ignore = "Integration test - requires running ORCHER server"]
async fn test_state_manager_creation() {
let actor_key = ActorKey::new("ShoppingCart", "user-123");
let state_client = Arc::new(
ActorStateClient::new(ActorStateClientConfig::default())
.await
.unwrap(),
);
let execution_id = "exec-456".to_string();
let manager = ActorStateManager::new(actor_key, state_client, execution_id);
assert_eq!(manager.actor_name(), "ShoppingCart");
assert_eq!(manager.key(), "user-123");
assert_eq!(manager.execution_id(), "exec-456");
}
#[tokio::test]
#[ignore = "Integration test - requires running ORCHER server"]
async fn test_state_manager_accessors() {
let actor_key = ActorKey::new("BankAccount", "account-789");
let state_client = Arc::new(
ActorStateClient::new(ActorStateClientConfig::default())
.await
.unwrap(),
);
let manager =
ActorStateManager::new(actor_key.clone(), state_client, "exec-999".to_string());
assert_eq!(manager.actor_key(), &actor_key);
assert_eq!(manager.actor_name(), "BankAccount");
assert_eq!(manager.key(), "account-789");
}
#[tokio::test]
#[ignore = "Integration test - requires running ORCHER server"]
async fn test_state_manager_clone() {
let actor_key = ActorKey::new("ShoppingCart", "user-123");
let state_client = Arc::new(
ActorStateClient::new(ActorStateClientConfig::default())
.await
.unwrap(),
);
let manager1 = ActorStateManager::new(actor_key, state_client, "exec-123".to_string());
let manager2 = manager1.clone();
assert_eq!(manager1.actor_name(), manager2.actor_name());
assert_eq!(manager1.key(), manager2.key());
assert_eq!(manager1.execution_id(), manager2.execution_id());
}
}