From d6c2e289ff2d2a8c89b54b9f326a12ccd9845290 Mon Sep 17 00:00:00 2001 From: jake Date: Sat, 30 Jul 2022 14:33:22 -0600 Subject: [PATCH] use async mutexes in inmemorygateway and reimplement inmemorygateway transactions --- src/entity/gateway/inmemory.rs | 401 ++++++++++++++++++++++----------- 1 file changed, 273 insertions(+), 128 deletions(-) diff --git a/src/entity/gateway/inmemory.rs b/src/entity/gateway/inmemory.rs index 965b478..560d683 100644 --- a/src/entity/gateway/inmemory.rs +++ b/src/entity/gateway/inmemory.rs @@ -7,57 +7,199 @@ use crate::entity::character::*; use crate::entity::gateway::{EntityGateway, EntityGatewayTransaction, GatewayError}; use crate::entity::item::*; -use std::sync::{Arc, Mutex}; +use async_std::sync::{Arc, Mutex}; // TODO: implement multiple banks - pub struct InMemoryGatewayTransaction<'a> { working_gateway: InMemoryGateway, original_gateway: &'a mut InMemoryGateway, } + +fn copy_if_needed(working_table: &mut BTreeMap, original_table: &BTreeMap, key: K) -> Option<()> +where + K: Ord + Copy, + V: Clone, +{ + if !working_table.contains_key(&key) { + working_table.insert(key, original_table.get(&key)?.clone()); + } + + Some(()) +} + +// functions here have been skipped as they are not used in transactions, add as needed #[async_trait::async_trait] -impl<'a> EntityGatewayTransaction for InMemoryGatewayTransaction<'a> { - fn gateway(&mut self) -> &mut dyn EntityGateway { - &mut self.working_gateway +impl<'a> EntityGateway for InMemoryGatewayTransaction<'a> { + async fn create_user(&mut self, user: NewUserAccountEntity) -> Result { + self.working_gateway.create_user(user).await } - async fn commit(mut self: Box) -> Result<(), GatewayError> { - self.original_gateway.users.lock().unwrap().clear(); - self.original_gateway.users.lock().unwrap().extend(self.working_gateway.users.lock().unwrap().clone()); + async fn get_user_by_id(&mut self, id: UserAccountId) -> Result { + match self.working_gateway.get_user_by_id(id).await { + Ok(user) => Ok(user), + Err(_) => { + self.original_gateway.get_user_by_id(id).await + } + } + } - self.original_gateway.user_settings.lock().unwrap().clear(); - self.original_gateway.user_settings.lock().unwrap().extend(self.working_gateway.user_settings.lock().unwrap().clone()); + async fn get_user_by_name(&mut self, username: String) -> Result { + match self.working_gateway.get_user_by_name(username.clone()).await { + Ok(user) => Ok(user), + Err(_) => { + self.original_gateway.get_user_by_name(username).await + } + } + } - self.original_gateway.characters.lock().unwrap().clear(); - self.original_gateway.characters.lock().unwrap().extend(self.working_gateway.characters.lock().unwrap().clone()); + async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError> { + self.working_gateway.save_user(user).await + } - self.original_gateway.character_meseta.lock().unwrap().clear(); - self.original_gateway.character_meseta.lock().unwrap().extend(self.working_gateway.character_meseta.lock().unwrap().clone()); + async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result { + self.working_gateway.create_user_settings(settings).await + } - self.original_gateway.bank_meseta.lock().unwrap().clear(); - self.original_gateway.bank_meseta.lock().unwrap().extend(self.working_gateway.bank_meseta.lock().unwrap().clone()); + async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result { + match self.working_gateway.get_user_settings_by_user(user).await { + Ok(user) => Ok(user), + Err(_) => { + self.original_gateway.get_user_settings_by_user(user).await + } + } + } + + async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError> { + copy_if_needed(&mut *self.working_gateway.characters.lock().await, + &*self.original_gateway.characters.lock().await, + char.id + ); + self.working_gateway.save_character(char).await + } + + async fn create_item(&mut self, item: NewItemEntity) -> Result { + self.working_gateway.create_item(item).await + } - self.original_gateway.items.lock().unwrap().clear(); - self.original_gateway.items.lock().unwrap().extend(self.working_gateway.items.lock().unwrap().clone()); + async fn add_item_note(&mut self, item_id: &ItemEntityId, item_note: ItemNote) -> Result<(), GatewayError> { + self.working_gateway.add_item_note(item_id, item_note).await + } - self.original_gateway.inventories.lock().unwrap().clear(); - self.original_gateway.inventories.lock().unwrap().extend(self.working_gateway.inventories.lock().unwrap().clone()); + async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> { + self.working_gateway.feed_mag(mag_item_id, tool_item_id).await + } - self.original_gateway.banks.lock().unwrap().clear(); - self.original_gateway.banks.lock().unwrap().extend(self.working_gateway.banks.lock().unwrap().clone()); + async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> { + self.working_gateway.change_mag_owner(mag_item_id, character).await + } - self.original_gateway.equips.lock().unwrap().clear(); - self.original_gateway.equips.lock().unwrap().extend(self.working_gateway.equips.lock().unwrap().clone()); + async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> { + self.working_gateway.use_mag_cell(mag_item_id, mag_cell_id).await + } - self.original_gateway.mag_modifiers.lock().unwrap().clear(); - self.original_gateway.mag_modifiers.lock().unwrap().extend(self.working_gateway.mag_modifiers.lock().unwrap().clone()); + async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: weapon::WeaponModifier) -> Result<(), GatewayError> { + self.working_gateway.add_weapon_modifier(item_id, modifier).await + } - self.original_gateway.weapon_modifiers.lock().unwrap().clear(); - self.original_gateway.weapon_modifiers.lock().unwrap().extend(self.working_gateway.weapon_modifiers.lock().unwrap().clone()); + async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result { + match self.working_gateway.get_character_inventory(char_id).await { + Ok(inventory) => Ok(inventory), + Err(_) => { + self.original_gateway.get_character_inventory(char_id).await + } + } + } - self.original_gateway.trades.lock().unwrap().clear(); - self.original_gateway.trades.lock().unwrap().extend(self.working_gateway.trades.lock().unwrap().clone()); + async fn get_character_bank(&mut self, char_id: &CharacterEntityId, bank_name: &BankName) -> Result { + match self.working_gateway.get_character_bank(char_id, bank_name).await { + Ok(bank) => Ok(bank), + Err(_) => { + self.original_gateway.get_character_bank(char_id, bank_name).await + } + } + } + + async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> { + self.working_gateway.set_character_inventory(char_id, inventory).await + } + + async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, bank_name: &BankName) -> Result<(), GatewayError> { + self.working_gateway.set_character_bank(char_id, bank, bank_name).await + } + + + async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result { + match self.working_gateway.get_character_equips(char_id).await { + Ok(equips) => Ok(equips), + Err(_) => { + self.original_gateway.get_character_equips(char_id).await + } + } + } + + async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> { + self.working_gateway.set_character_equips(char_id, equipped).await + } + + async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> { + self.working_gateway.set_character_meseta(char_id, meseta).await + } + + async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result { + match self.working_gateway.get_character_meseta(char_id).await { + Ok(meseta) => Ok(meseta), + Err(_) => { + self.original_gateway.get_character_meseta(char_id).await + } + } + } + + async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: &BankName, meseta: Meseta) -> Result<(), GatewayError> { + self.working_gateway.set_bank_meseta(char_id, bank, meseta).await + } + + async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: &BankName) -> Result { + match self.working_gateway.get_bank_meseta(char_id, bank).await { + Ok(meseta) => Ok(meseta), + Err(_) => { + self.original_gateway.get_bank_meseta(char_id, bank).await + } + } + } + + async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result { + self.working_gateway.create_trade(char_id1, char_id2).await + } + + async fn set_character_playtime(&mut self, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError> { + copy_if_needed(&mut *self.working_gateway.characters.lock().await, + &*self.original_gateway.characters.lock().await, + *char_id + ); + self.working_gateway.set_character_playtime(char_id, playtime).await + } +} + +#[async_trait::async_trait] +impl<'a> EntityGatewayTransaction for InMemoryGatewayTransaction<'a> { + fn gateway(&mut self) -> &mut dyn EntityGateway { + self + } + + async fn commit(mut self: Box) -> Result<(), GatewayError> { + self.original_gateway.users.lock().await.extend(self.working_gateway.users.lock().await.clone()); + self.original_gateway.user_settings.lock().await.extend(self.working_gateway.user_settings.lock().await.clone()); + self.original_gateway.characters.lock().await.extend(self.working_gateway.characters.lock().await.clone()); + self.original_gateway.character_meseta.lock().await.extend(self.working_gateway.character_meseta.lock().await.clone()); + self.original_gateway.bank_meseta.lock().await.extend(self.working_gateway.bank_meseta.lock().await.clone()); + self.original_gateway.items.lock().await.extend(self.working_gateway.items.lock().await.clone()); + self.original_gateway.inventories.lock().await.extend(self.working_gateway.inventories.lock().await.clone()); + self.original_gateway.banks.lock().await.extend(self.working_gateway.banks.lock().await.clone()); + self.original_gateway.equips.lock().await.extend(self.working_gateway.equips.lock().await.clone()); + self.original_gateway.mag_modifiers.lock().await.extend(self.working_gateway.mag_modifiers.lock().await.clone()); + self.original_gateway.weapon_modifiers.lock().await.extend(self.working_gateway.weapon_modifiers.lock().await.clone()); + self.original_gateway.trades.lock().await.extend(self.working_gateway.trades.lock().await.clone()); Ok(()) } @@ -98,60 +240,60 @@ impl Default for InMemoryGateway { } } -impl InMemoryGateway { - fn apply_modifiers(&self, inventory: InventoryEntity ) -> InventoryEntity { - let items = self.items.lock().unwrap(); - let inventory_items = inventory.items.into_iter() - .map(|item| { - item.map_individual(|mut item| { - item.item = match item.item { - ItemDetail::Weapon(mut weapon) => { - if let Some(weapon_modifiers) = self.weapon_modifiers.lock().unwrap().get(&item.id) { - for weapon_modifier in weapon_modifiers.iter() { - weapon.apply_modifier(weapon_modifier); - } +fn apply_modifiers(items: &BTreeMap, + weapon_modifiers: &BTreeMap>, + mag_modifiers: &BTreeMap>, + inventory: InventoryEntity ) -> InventoryEntity { + let inventory_items = inventory.items.into_iter() + .map(|item| { + item.map_individual(|mut item| { + item.item = match item.item { + ItemDetail::Weapon(mut weapon) => { + if let Some(weapon_modifiers) = weapon_modifiers.get(&item.id) { + for weapon_modifier in weapon_modifiers.iter() { + weapon.apply_modifier(weapon_modifier); } - ItemDetail::Weapon(weapon) - }, - ItemDetail::Mag(mag) => { - let mut mag = mag::Mag::baby_mag(mag.color as u16); - if let Some(mag_modifiers) = self.mag_modifiers.lock().unwrap().get(&item.id) { - for mag_modifier in mag_modifiers.iter() { - match mag_modifier { - mag::MagModifier::FeedMag {food} => { - if let Some(mag_feed) = items.get(food) { - if let ItemDetail::Tool(mag_feed) = mag_feed.item { - mag.feed(mag_feed.tool) - } + } + ItemDetail::Weapon(weapon) + }, + ItemDetail::Mag(mag) => { + let mut mag = mag::Mag::baby_mag(mag.color as u16); + if let Some(mag_modifiers) = mag_modifiers.get(&item.id) { + for mag_modifier in mag_modifiers.iter() { + match mag_modifier { + mag::MagModifier::FeedMag {food} => { + if let Some(mag_feed) = items.get(food) { + if let ItemDetail::Tool(mag_feed) = mag_feed.item { + mag.feed(mag_feed.tool) } - }, - mag::MagModifier::OwnerChange(class, section_id) => { - mag.change_owner(*class, *section_id) - }, - mag::MagModifier::MagCell(mag_cell_id) => { - if let Some(mag_cell) = items.get(mag_cell_id) { - if let ItemDetail::Tool(mag_cell) = mag_cell.item { - mag.apply_mag_cell(mag_cell.tool.try_into().unwrap()).unwrap() - } + } + }, + mag::MagModifier::OwnerChange(class, section_id) => { + mag.change_owner(*class, *section_id) + }, + mag::MagModifier::MagCell(mag_cell_id) => { + if let Some(mag_cell) = items.get(mag_cell_id) { + if let ItemDetail::Tool(mag_cell) = mag_cell.item { + mag.apply_mag_cell(mag_cell.tool.try_into().unwrap()).unwrap() } - }, - _ => {} - } + } + }, + _ => {} } } - ItemDetail::Mag(mag) } - _ => { - item.item - } - }; - - item - }) + ItemDetail::Mag(mag) + } + _ => { + item.item + } + }; + + item }) - .collect(); - InventoryEntity::new(inventory_items) - } + }) + .collect(); + InventoryEntity::new(inventory_items) } #[async_trait::async_trait] @@ -159,18 +301,18 @@ impl EntityGateway for InMemoryGateway { async fn transaction<'a>(&'a mut self) -> Result, GatewayError> { let working_gateway = { - let users = self.users.lock().unwrap().clone(); - let user_settings = self.user_settings.lock().unwrap().clone(); - let characters = self.characters.lock().unwrap().clone(); - let character_meseta = self.character_meseta.lock().unwrap().clone(); - let bank_meseta = self.bank_meseta.lock().unwrap().clone(); - let items = self.items.lock().unwrap().clone(); - let inventories = self.inventories.lock().unwrap().clone(); - let banks = self.banks.lock().unwrap().clone(); - let equips = self.equips.lock().unwrap().clone(); - let mag_modifiers = self.mag_modifiers.lock().unwrap().clone(); - let weapon_modifiers = self.weapon_modifiers.lock().unwrap().clone(); - let trades = self.trades.lock().unwrap().clone(); + let users = self.users.lock().await.clone(); + let user_settings = self.user_settings.lock().await.clone(); + let characters = self.characters.lock().await.clone(); + let character_meseta = self.character_meseta.lock().await.clone(); + let bank_meseta = self.bank_meseta.lock().await.clone(); + let items = self.items.lock().await.clone(); + let inventories = self.inventories.lock().await.clone(); + let banks = self.banks.lock().await.clone(); + let equips = self.equips.lock().await.clone(); + let mag_modifiers = self.mag_modifiers.lock().await.clone(); + let weapon_modifiers = self.weapon_modifiers.lock().await.clone(); + let trades = self.trades.lock().await.clone(); InMemoryGateway { users: Arc::new(Mutex::new(users)), @@ -202,18 +344,18 @@ impl EntityGateway for InMemoryGateway { R: Send, E: From, { - let users = self.users.lock().unwrap().clone(); - let user_settings = self.user_settings.lock().unwrap().clone(); - let characters = self.characters.lock().unwrap().clone(); - let character_meseta = self.character_meseta.lock().unwrap().clone(); - let bank_meseta = self.bank_meseta.lock().unwrap().clone(); - let items = self.items.lock().unwrap().clone(); - let inventories = self.inventories.lock().unwrap().clone(); - let banks = self.banks.lock().unwrap().clone(); - let equips = self.equips.lock().unwrap().clone(); - let mag_modifiers = self.mag_modifiers.lock().unwrap().clone(); - let weapon_modifiers = self.weapon_modifiers.lock().unwrap().clone(); - let trades = self.trades.lock().unwrap().clone(); + let users = self.users.lock().await.clone(); + let user_settings = self.user_settings.lock().await.clone(); + let characters = self.characters.lock().await.clone(); + let character_meseta = self.character_meseta.lock().await.clone(); + let bank_meseta = self.bank_meseta.lock().await.clone(); + let items = self.items.lock().await.clone(); + let inventories = self.inventories.lock().await.clone(); + let banks = self.banks.lock().await.clone(); + let equips = self.equips.lock().await.clone(); + let mag_modifiers = self.mag_modifiers.lock().await.clone(); + let weapon_modifiers = self.weapon_modifiers.lock().await.clone(); + let trades = self.trades.lock().await.clone(); let working_gateway = InMemoryGateway { users: Arc::new(Mutex::new(users)), @@ -242,7 +384,7 @@ impl EntityGateway for InMemoryGateway { } async fn create_user(&mut self, user: NewUserAccountEntity) -> Result { - let mut users = self.users.lock().unwrap(); + let mut users = self.users.lock().await; let id = users .iter() .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0)) @@ -267,12 +409,12 @@ impl EntityGateway for InMemoryGateway { } async fn get_user_by_id(&mut self, id: UserAccountId) -> Result { - let users = self.users.lock().unwrap(); + let users = self.users.lock().await; users.get(&id).cloned().ok_or(GatewayError::Error) } async fn get_user_by_name(&mut self, username: String) -> Result { - let users = self.users.lock().unwrap(); + let users = self.users.lock().await; users .iter() .find(|(_, k)| k.username == username) @@ -281,13 +423,13 @@ impl EntityGateway for InMemoryGateway { } async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError> { - let mut users = self.users.lock().unwrap(); + let mut users = self.users.lock().await; users.insert(user.id, user.clone()); Ok(()) } async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result { - let mut user_settings = self.user_settings.lock().unwrap(); + let mut user_settings = self.user_settings.lock().await; let id = user_settings .iter() .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0)) @@ -302,7 +444,7 @@ impl EntityGateway for InMemoryGateway { } async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result { - let user_settings = self.user_settings.lock().unwrap(); + let user_settings = self.user_settings.lock().await; user_settings .iter() .find(|(_, k)| k.user_id == user.id) @@ -311,7 +453,7 @@ impl EntityGateway for InMemoryGateway { } async fn get_characters_by_user(&mut self, user: &UserAccountEntity) -> Result<[Option; 4], GatewayError> { - let characters = self.characters.lock().unwrap(); + let characters = self.characters.lock().await; const NONE: Option = None; let mut chars = [NONE; 4]; characters @@ -322,7 +464,7 @@ impl EntityGateway for InMemoryGateway { } async fn create_character(&mut self, character: NewCharacterEntity) -> Result { - let mut characters = self.characters.lock().unwrap(); + let mut characters = self.characters.lock().await; let id = characters .iter() .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0)) @@ -353,7 +495,7 @@ impl EntityGateway for InMemoryGateway { } async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError> { - let mut characters = self.characters.lock().unwrap(); + let mut characters = self.characters.lock().await; characters.insert(char.id, char.clone()); Ok(()) } @@ -363,7 +505,7 @@ impl EntityGateway for InMemoryGateway { } async fn create_item(&mut self, item: NewItemEntity) -> Result { - let mut items = self.items.lock().unwrap(); + let mut items = self.items.lock().await; let id = items .iter() .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0)) @@ -381,7 +523,7 @@ impl EntityGateway for InMemoryGateway { } async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> { - self.mag_modifiers.lock().unwrap() + self.mag_modifiers.lock().await .entry(*mag_item_id) .or_insert_with(Vec::new) .push(mag::MagModifier::FeedMag { @@ -391,7 +533,7 @@ impl EntityGateway for InMemoryGateway { } async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> { - self.mag_modifiers.lock().unwrap() + self.mag_modifiers.lock().await .entry(*mag_item_id) .or_insert_with(Vec::new) .push(mag::MagModifier::OwnerChange(character.char_class, character.section_id)); @@ -399,7 +541,7 @@ impl EntityGateway for InMemoryGateway { } async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> { - self.mag_modifiers.lock().unwrap() + self.mag_modifiers.lock().await .entry(*mag_item_id) .or_insert_with(Vec::new) .push(mag::MagModifier::MagCell(*mag_cell_id)); @@ -407,7 +549,7 @@ impl EntityGateway for InMemoryGateway { } async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: weapon::WeaponModifier) -> Result<(), GatewayError> { - self.weapon_modifiers.lock().unwrap() + self.weapon_modifiers.lock().await .entry(*item_id) .or_insert_with(Vec::new) .push(modifier); @@ -415,17 +557,20 @@ impl EntityGateway for InMemoryGateway { } async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result { - let inventories = self.inventories.lock().unwrap(); + let inventories = self.inventories.lock().await; + let items = self.items.lock().await; + let weapon_modifiers = self.weapon_modifiers.lock().await; + let mag_modifiers = self.mag_modifiers.lock().await; Ok(inventories .iter() .find(|(id, _)| **id == *char_id) .map(|(_, inv)| inv.clone()) - .map(|inv| self.apply_modifiers(inv)) + .map(|inv| apply_modifiers(&items, &weapon_modifiers, &mag_modifiers, inv)) .unwrap_or_default()) } async fn get_character_bank(&mut self, char_id: &CharacterEntityId, _bank_name: &BankName) -> Result { - let banks = self.banks.lock().unwrap(); + let banks = self.banks.lock().await; Ok(banks .iter() .find(|(id, _)| **id == *char_id) @@ -434,20 +579,20 @@ impl EntityGateway for InMemoryGateway { } async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> { - let mut inventories = self.inventories.lock().unwrap(); + let mut inventories = self.inventories.lock().await; inventories.insert(*char_id, inventory.clone()); Ok(()) } // TOOD: impl bank name async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, _bank_name: &BankName) -> Result<(), GatewayError> { - let mut banks = self.banks.lock().unwrap(); + let mut banks = self.banks.lock().await; banks.insert(*char_id, bank.clone()); Ok(()) } async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result { - let equips = self.equips.lock().unwrap(); + let equips = self.equips.lock().await; Ok(equips .iter() .find(|(id, _)| **id == *char_id) @@ -456,19 +601,19 @@ impl EntityGateway for InMemoryGateway { } async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> { - let mut equips = self.equips.lock().unwrap(); + let mut equips = self.equips.lock().await; equips.insert(*char_id, equipped.clone()); Ok(()) } async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> { - let mut character_meseta = self.character_meseta.lock().unwrap(); + let mut character_meseta = self.character_meseta.lock().await; character_meseta.insert(*char_id, meseta); Ok(()) } async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result { - let mut character_meseta = self.character_meseta.lock().unwrap(); + let mut character_meseta = self.character_meseta.lock().await; if let Some(meseta) = character_meseta.get_mut(char_id) { Ok(*meseta) } @@ -478,13 +623,13 @@ impl EntityGateway for InMemoryGateway { } async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: &BankName, meseta: Meseta) -> Result<(), GatewayError> { - let mut bank_meseta = self.bank_meseta.lock().unwrap(); + let mut bank_meseta = self.bank_meseta.lock().await; bank_meseta.insert((*char_id, bank.clone()), meseta); Ok(()) } async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: &BankName) -> Result { - let mut bank_meseta = self.bank_meseta.lock().unwrap(); + let mut bank_meseta = self.bank_meseta.lock().await; if let Some(meseta) = bank_meseta.get_mut(&(*char_id, bank.clone())) { Ok(*meseta) } @@ -494,7 +639,7 @@ impl EntityGateway for InMemoryGateway { } async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result { - let mut trades = self.trades.lock().unwrap(); + let mut trades = self.trades.lock().await; let id = trades.len() as u32; let new_trade = TradeEntity { id: TradeId(id), @@ -506,7 +651,7 @@ impl EntityGateway for InMemoryGateway { } async fn set_character_playtime(&mut self, char_id: &CharacterEntityId, playtime: u32) -> Result<(), GatewayError> { - let mut characters = self.characters.lock().unwrap(); + let mut characters = self.characters.lock().await; if let Some(character) = characters.get_mut(char_id) { character.playtime = playtime; Ok(())