From 1ccca96cc25fac31e91142335e3b0b8298001f95 Mon Sep 17 00:00:00 2001 From: Ben Date: Fri, 27 Mar 2020 03:13:48 +0000 Subject: [PATCH] Switch from aiocache to cacheout library --- houdini/handlers/play/epf.py | 9 +- houdini/handlers/play/experience.py | 30 +++--- houdini/handlers/play/igloo.py | 141 +++++++++++++++------------- houdini/handlers/play/item.py | 31 +++--- houdini/handlers/play/player.py | 21 ++--- houdini/handlers/play/stampbook.py | 24 ++--- houdini/houdini.py | 9 +- houdini/penguin.py | 6 +- requirements.txt | 2 +- 9 files changed, 127 insertions(+), 146 deletions(-) diff --git a/houdini/handlers/play/epf.py b/houdini/handlers/play/epf.py index 069a06d..9b3fe50 100644 --- a/houdini/handlers/play/epf.py +++ b/houdini/handlers/play/epf.py @@ -2,8 +2,6 @@ import datetime import random import time -from aiocache import cached - from houdini import handlers from houdini.constants import ClientType from houdini.data.item import Item @@ -13,7 +11,6 @@ from houdini.handlers import XTPacket from houdini.handlers.play.mail import handle_start_mail_engine -@cached(alias='default', key='com_messages') async def get_com_messages(p): async with p.server.db.transaction(): messages = [] @@ -123,9 +120,11 @@ async def handle_get_com_messages(p): unread_com_message = await EpfComMessage.query.where( EpfComMessage.date > p.com_message_read_date).gino.scalar() if unread_com_message: - await p.server.cache.delete('com_messages') + p.server.cache.delete('com_messages') await p.update(com_message_read_date=datetime.datetime.now()).apply() - com_messages = await get_com_messages(p) + com_messages = p.server.cache.get('com_messages') + com_messages = await get_com_messages(p) if com_messages is None else com_messages + p.server.cache.set('com_messages', com_messages) if com_messages: await p.send_xt('epfgm', int(bool(unread_com_message)), com_messages) else: diff --git a/houdini/handlers/play/experience.py b/houdini/handlers/play/experience.py index 1b060a4..4bfa4c9 100644 --- a/houdini/handlers/play/experience.py +++ b/houdini/handlers/play/experience.py @@ -1,5 +1,4 @@ import ujson -from aiocache import cached from houdini import handlers from houdini.data import db @@ -9,15 +8,6 @@ from houdini.handlers import XTPacket from houdini.handlers.play.navigation import handle_join_player_room, handle_join_room, handle_join_server -def get_status_key(_, p): - return f'quest.status.{p.id}' - - -def get_settings_key(_, p): - return f'quest.settings.{p.room.id}' - - -@cached(alias='default', key_builder=get_status_key) async def get_player_quest_status(p): query = Quest.load(tasks=QuestTask, items=QuestAwardItem, @@ -63,7 +53,6 @@ AwardTypes = { } -@cached(alias='default', key_builder=get_settings_key) async def get_quest_settings(p): query = Quest.load(items=QuestAwardItem, furniture=QuestAwardFurniture, @@ -127,15 +116,22 @@ async def load_active_quests(p): @handlers.handler(XTPacket('j', 'js'), after=handle_join_server) @handlers.allow_once async def handle_quest_join_server(p): - await p.server.cache.delete(f'quest.status.{p.id}') + p.server.cache.delete(f'quest.status.{p.id}') await load_active_quests(p) - await p.send_xt('nxquestsettings', await get_quest_settings(p)) - await p.send_xt('nxquestdata', await get_player_quest_status(p)) + quest_settings = p.server.cache.get(f'quest.settings.{p.room.id}') + quest_status = p.server.cache.get(f'quest.status.{p.id}') + quest_settings = await get_quest_settings(p) if quest_settings is None else quest_settings + quest_status = await get_player_quest_status(p) if quest_status is None else quest_status + p.server.cache.set(f'quest.settings.{p.room.id}', quest_settings) + p.server.cache.set(f'quest.status.{p.id}', quest_status) + + await p.send_xt('nxquestsettings', quest_settings) + await p.send_xt('nxquestdata', quest_status) async def set_task_cleared(p, task_id): - await p.server.cache.delete(f'quest.status.{p.id}') + p.server.cache.delete(f'quest.status.{p.id}') await PenguinQuestTask.update.values(complete=True) \ .where((PenguinQuestTask.task_id == task_id) & @@ -166,7 +162,7 @@ async def handle_quest_join_player_room(p): @handlers.handler(XTPacket('nx', 'nxquestaward')) async def handle_quest_award(p, quest_id: int): - await p.server.cache.delete(f'quest.status.{p.id}') + p.server.cache.delete(f'quest.status.{p.id}') quest = await Quest.load(items=QuestAwardItem, furniture=QuestAwardFurniture, @@ -183,7 +179,7 @@ async def handle_quest_award(p, quest_id: int): @handlers.handler(XTPacket('nx', 'nxquestactivate')) @handlers.allow_once async def handle_quest_activate(p): - await p.server.cache.delete(f'quest.status.{p.id}') + p.server.cache.delete(f'quest.status.{p.id}') await init_all_quests(p) await p.send_xt('nxquestdata', await get_player_quest_status(p)) diff --git a/houdini/handlers/play/igloo.py b/houdini/handlers/play/igloo.py index a1935bc..f2019bb 100644 --- a/houdini/handlers/play/igloo.py +++ b/houdini/handlers/play/igloo.py @@ -3,7 +3,6 @@ import time from datetime import datetime, timedelta import ujson -from aiocache import cached from sqlalchemy.dialects.postgresql import insert from houdini import handlers @@ -20,27 +19,6 @@ from houdini.handlers import Priority, XMLPacket, XTPacket from houdini.handlers.play.navigation import handle_join_server -def get_layout_furniture_key(_, p, igloo_id): - return f'layout_furniture.{igloo_id}' - - -def get_active_igloo_string_key(_, p, penguin_id): - return f'active_igloo.{penguin_id}' - - -def get_legacy_igloo_string_key(_, p, penguin_id): - return f'legacy_igloo.{penguin_id}' - - -def get_igloo_layouts_key(_, p): - return f'igloo_layouts.{p.id}' - - -def get_layout_like_count_key(_, igloo_id): - return f'layout_like_count.{igloo_id}' - - -@cached(alias='default', key_builder=get_layout_furniture_key) async def get_layout_furniture(p, igloo_id): igloo_furniture = IglooFurniture.query.where(IglooFurniture.igloo_id == igloo_id).gino async with p.server.db.transaction(): @@ -50,41 +28,48 @@ async def get_layout_furniture(p, igloo_id): return furniture_string -@cached(alias='default', key_builder=get_active_igloo_string_key) -async def get_active_igloo_string(p, penguin_id): - igloo = await PenguinIglooRoom.load(parent=Penguin.on(Penguin.igloo == PenguinIglooRoom.id))\ - .where(PenguinIglooRoom.penguin_id == penguin_id).gino.first() +async def get_igloo(penguin_id): + return await PenguinIglooRoom.load(parent=Penguin.on(Penguin.igloo == PenguinIglooRoom.id))\ + .where(PenguinIglooRoom.penguin_id == penguin_id).gino.first() - furniture_string = await get_layout_furniture(p, igloo.id) - like_count = await get_layout_like_count(igloo.id) + +async def get_active_igloo_string(p, penguin_id): + igloo = await get_igloo(penguin_id) + furniture_string = p.server.cache.get(f'layout_furniture.{igloo.id}') + furniture_string = await get_layout_furniture(p, igloo.id) if furniture_string is None else furniture_string + like_count = p.server.cache.get(f'layout_like_count.{igloo.id}') + like_count = await get_layout_like_count(igloo.id) if like_count is None else like_count + + p.server.cache.set(f'layout_furniture.{igloo.id}', furniture_string) + p.server.cache.set(f'layout_like_count.{igloo.id}', like_count) return f'{igloo.id}:1:0:{int(igloo.locked)}:{igloo.music}:{igloo.flooring}:' \ f'{igloo.location}:{igloo.type}:{like_count}:{furniture_string}' -@cached(alias='default', key_builder=get_legacy_igloo_string_key) async def get_legacy_igloo_string(p, penguin_id): - igloo = await PenguinIglooRoom.load(parent=Penguin.on(Penguin.igloo == PenguinIglooRoom.id))\ - .where(PenguinIglooRoom.penguin_id == penguin_id).gino.first() - - furniture_string = await get_layout_furniture(p, igloo.id) + igloo = await get_igloo(penguin_id) + furniture_string = p.server.cache.get(f'layout_furniture.{igloo.id}') + furniture_string = await get_layout_furniture(p, igloo.id) if furniture_string is None else furniture_string + p.server.cache.set(f'layout_furniture.{igloo.id}', furniture_string) return f'{igloo.type}%{igloo.music}%{igloo.flooring}%{furniture_string}' -@cached(alias='default', key_builder=get_igloo_layouts_key) async def get_all_igloo_layouts(p): layout_details = [] - slot = 0 - for igloo in p.igloo_rooms.values(): - slot += 1 - furniture_string = await get_layout_furniture(p, igloo.id) - like_count = await get_layout_like_count(igloo.id) + for slot, igloo in enumerate(p.igloo_rooms.values()): + furniture_string = p.server.cache.get(f'layout_furniture.{igloo.id}') + furniture_string = await get_layout_furniture(p, igloo.id) if furniture_string is None else furniture_string + like_count = p.server.cache.get(f'layout_like_count.{igloo.id}') + like_count = await get_layout_like_count(igloo.id) if like_count is None else like_count + + p.server.cache.set(f'layout_furniture.{igloo.id}', furniture_string) + p.server.cache.set(f'layout_like_count.{igloo.id}', like_count) igloo_details = f'{igloo.id}:{slot}:0:{int(igloo.locked)}:{igloo.music}:{igloo.flooring}' \ f':{igloo.location}:{igloo.type}:{like_count}:{furniture_string}' layout_details.append(igloo_details) return '%'.join(layout_details) -@cached(alias='default', key_builder=get_layout_like_count_key) async def get_layout_like_count(igloo_id): layout_like_count = await db.select([db.func.sum(IglooLike.count)])\ .where(IglooLike.igloo_id == igloo_id).gino.scalar() @@ -180,14 +165,21 @@ async def load_igloo_inventory(p): @handlers.cooldown(1) async def handle_get_igloo_details(p, penguin_id: int): await create_first_igloo(p, penguin_id) + cache_key = f'active_igloo.{penguin_id}' if p.is_vanilla_client else f'legacy_igloo.{penguin_id}' igloo_string_method = get_active_igloo_string if p.is_vanilla_client else get_legacy_igloo_string - await p.send_xt('gm', penguin_id, await igloo_string_method(p, penguin_id)) + igloo_string = p.server.cache.get(cache_key) + igloo_string = await igloo_string_method(p, penguin_id) if igloo_string is None else igloo_string + p.server.cache.set(cache_key, igloo_string) + await p.send_xt('gm', penguin_id, igloo_string) @handlers.handler(XTPacket('g', 'gail'), client=ClientType.Vanilla) async def handle_get_all_igloo_layouts(p): await p.status_field_set(StatusField.OpenedIglooViewer) - await p.send_xt('gail', p.id, 0, await get_all_igloo_layouts(p)) + layouts_string = p.server.cache.get(f'igloo_layouts.{p.id}') + layouts_string = await get_all_igloo_layouts(p) if layouts_string is None else layouts_string + p.server.cache.set(f'igloo_layouts.{p.id}', layouts_string) + await p.send_xt('gail', p.id, 0, layouts_string) @handlers.handler(XTPacket('g', 'gail'), client=ClientType.Vanilla, after=handle_get_all_igloo_layouts) @@ -195,7 +187,9 @@ async def handle_get_all_igloo_likes(p): total = 0 like_strings = [] for igloo in p.igloo_rooms.values(): - like_count = await get_layout_like_count(igloo.id) + like_count = p.server.cache.get(f'layout_like_count.{igloo.id}') + like_count = await get_layout_like_count(igloo.id) if like_count is None else like_count + p.server.cache.set(f'layout_like_count.{igloo.id}', like_count) total += like_count like_strings.append(f'{igloo.id}|{like_count}') await p.send_xt('gaili', total, ','.join(like_strings)) @@ -222,9 +216,9 @@ async def handle_buy_flooring(p, flooring: Flooring): await p.send_xt('ag', flooring.id, p.coins) - await p.server.cache.delete(f'active_igloo.{p.id}') - await p.server.cache.delete(f'legacy_igloo.{p.id}') - await p.server.cache.delete(f'igloo_layouts.{p.id}') + p.server.cache.delete(f'active_igloo.{p.id}') + p.server.cache.delete(f'legacy_igloo.{p.id}') + p.server.cache.delete(f'igloo_layouts.{p.id}') @handlers.handler(XTPacket('g', 'aloc'), client=ClientType.Vanilla) @@ -292,15 +286,17 @@ async def handle_update_igloo_configuration(p, igloo_id: int, igloo_type_id: int music=music_id ).apply() - like_count = await get_layout_like_count(igloo.id) + like_count = p.server.cache.get(f'layout_like_count.{igloo.id}') + like_count = await get_layout_like_count(igloo.id) if like_count is None else like_count + p.server.cache.set(f'layout_like_count.{igloo.id}', like_count) active_igloo_string = f'{igloo.id}:1:0:{int(igloo.locked)}:{igloo.music}:{igloo.flooring}:' \ f'{igloo.location}:{igloo.type}:{like_count}:{furniture_data}' await p.room.send_xt('uvi', p.id, active_igloo_string) - await p.server.cache.set(f'layout_furniture.{igloo.id}', furniture_data) - await p.server.cache.set(f'active_igloo.{p.id}', active_igloo_string) - await p.server.cache.delete(f'legacy_igloo.{p.id}') - await p.server.cache.delete(f'igloo_layouts.{p.id}') + p.server.cache.set(f'layout_furniture.{igloo.id}', furniture_data) + p.server.cache.set(f'active_igloo.{p.id}', active_igloo_string) + p.server.cache.delete(f'legacy_igloo.{p.id}') + p.server.cache.delete(f'igloo_layouts.{p.id}') @handlers.handler(XTPacket('g', 'ur'), client=ClientType.Legacy) @@ -308,8 +304,8 @@ async def handle_update_igloo_configuration(p, igloo_id: int, igloo_type_id: int async def handle_save_igloo_furniture(p, *furniture_data): await save_igloo_furniture(p, furniture_data) - await p.server.cache.set(f'layout_furniture.{p.igloo}', ','.join(furniture_data)) - await p.server.cache.delete(f'legacy_igloo.{p.id}') + p.server.cache.set(f'layout_furniture.{p.igloo}', ','.join(furniture_data)) + p.server.cache.delete(f'legacy_igloo.{p.id}') _slot_converter = SeparatorConverter(separator=',', mapper=str) @@ -350,9 +346,9 @@ async def handle_update_igloo_slot_summary(p, igloo_id: int, slot_summary: _slot if igloo.locked != bool(locked): await igloo.update(locked=bool(locked)).apply() - await p.server.cache.delete(f'active_igloo.{p.id}') - await p.server.cache.delete(f'legacy_igloo.{p.id}') - await p.server.cache.delete(f'igloo_layouts.{p.id}') + p.server.cache.delete(f'active_igloo.{p.id}') + p.server.cache.delete(f'legacy_igloo.{p.id}') + p.server.cache.delete(f'igloo_layouts.{p.id}') active_igloo_string = await get_active_igloo_string(p, p.id) await p.room.send_xt('uvi', p.id, active_igloo_string) @@ -393,7 +389,9 @@ async def handle_add_igloo_layout(p): @handlers.cooldown(1) async def handle_get_igloo_like_by(p, pagination_start: int, pagination_end: int): if p.room.igloo: - like_count = await get_layout_like_count(p.room.id) + like_count = p.server.cache.get(f'layout_like_count.{p.room.id}') + like_count = await get_layout_like_count(p.room.id) if like_count is None else like_count + p.server.cache.set(f'layout_like_count.{p.room.id}', like_count) liked_by = IglooLike.query.where(IglooLike.igloo_id == p.room.id). \ limit(pagination_end - pagination_start).offset(pagination_start).gino @@ -443,12 +441,20 @@ async def handle_can_like_igloo(p): async def handle_get_open_igloo_list(p): async def get_igloo_string(igloo): owner_name = p.server.penguins_by_id[igloo.penguin_id].safe_name - like_count = await get_layout_like_count(igloo.id) + like_count = p.server.cache.get(f'layout_like_count.{igloo.id}') + like_count = await get_layout_like_count(igloo.id) if like_count is None else like_count + p.server.cache.set(f'layout_like_count.{igloo.id}', like_count) igloo_population = len(igloo.penguins_by_id) return f'{igloo.penguin_id}|{owner_name}|{like_count}|{igloo_population}|{int(igloo.locked)}' open_igloos = [await get_igloo_string(igloo) for igloo in p.server.open_igloos_by_penguin_id.values()] local_room_population = 0 + + own_layout_like_count = p.server.cache.get(f'layout_like_count.{p.igloo}') + own_layout_like_count = 0 if p.igloo is None else await get_layout_like_count(p.igloo) \ + if own_layout_like_count is None else own_layout_like_count + p.server.cache.set(f'layout_like_count.{p.igloo}', own_layout_like_count) + own_layout_like_count = 0 if p.igloo is None else await get_layout_like_count(p.igloo) await p.send_xt('gr', own_layout_like_count, local_room_population, *open_igloos) @@ -494,9 +500,9 @@ async def handle_update_igloo_music(p, music_id: int): if p.room.igloo and p.room.penguin_id == p.id and p.room.music != music_id: await p.room.update(music=music_id).apply() - await p.server.cache.delete(f'active_igloo.{p.id}') - await p.server.cache.delete(f'legacy_igloo.{p.id}') - await p.server.cache.delete(f'igloo_layouts.{p.id}') + p.server.cache.delete(f'active_igloo.{p.id}') + p.server.cache.delete(f'legacy_igloo.{p.id}') + p.server.cache.delete(f'igloo_layouts.{p.id}') @handlers.handler(XTPacket('g', 'ao'), client=ClientType.Legacy) @@ -505,15 +511,18 @@ async def handle_activate_igloo_type(p, igloo_type_id: int): and igloo_type_id in p.igloos: await p.room.update(type=igloo_type_id, flooring=0).apply() - await p.server.cache.delete(f'active_igloo.{p.id}') - await p.server.cache.delete(f'legacy_igloo.{p.id}') - await p.server.cache.delete(f'igloo_layouts.{p.id}') + p.server.cache.delete(f'active_igloo.{p.id}') + p.server.cache.delete(f'legacy_igloo.{p.id}') + p.server.cache.delete(f'igloo_layouts.{p.id}') @handlers.handler(XTPacket('g', 'grf'), client=ClientType.Vanilla) async def handle_get_friends_igloo_list(p): async def get_friend_igloo_string(penguin): - like_count = 0 if penguin.igloo is None else await get_layout_like_count(penguin.igloo) + like_count = p.server.cache.get(f'layout_like_count.{penguin.igloo}') + like_count = 0 if penguin.igloo is None else await get_layout_like_count(penguin.igloo) \ + if like_count is None else like_count + p.server.cache.set(f'layout_like_count.{penguin.igloo}', like_count) return f'{penguin.id}|{like_count}' friend_igloos = [await get_friend_igloo_string(penguin) for penguin in p.server.penguins_by_id.values() @@ -535,7 +544,7 @@ async def handle_like_igloo(p): like_count = await like_insert.gino.scalar() await p.room.send_xt('lue', p.id, like_count, f=lambda penguin: penguin.id != p.id) - await p.server.cache.delete(f'layout_like_count.{p.room.id}') + p.server.cache.delete(f'layout_like_count.{p.room.id}') @handlers.handler(XTPacket('g', 'gii'), client=ClientType.Vanilla) diff --git a/houdini/handlers/play/item.py b/houdini/handlers/play/item.py index f697d68..5c219a1 100644 --- a/houdini/handlers/play/item.py +++ b/houdini/handlers/play/item.py @@ -1,40 +1,29 @@ import operator import time -from aiocache import cached - from houdini import handlers from houdini.data.item import Item, ItemCollection, PenguinItemCollection from houdini.data.permission import PenguinPermissionCollection from houdini.handlers import Priority, XMLPacket, XTPacket -def get_pin_string_key(_, p, player_id): - return f'pins.{player_id}' - - -def get_awards_string_key(_, p, player_id): - return f'awards.{player_id}' - - -@cached(alias='default', key_builder=get_pin_string_key) async def get_pin_string(p, player_id): if player_id in p.server.penguins_by_id: inventory = p.server.penguins_by_id[player_id].inventory else: inventory = await PenguinItemCollection.get_collection(player_id) + def is_free_pin(pin): + p.server.items[pin].is_flag() and p.server.items[pin].cost == 0 + free_pins = (p.server.items[pin] for pin in inventory.keys() if is_free_pin(pin)) + pins = sorted(free_pins, key=operator.attrgetter('release_date')) + def get_string(pin): unix = int(time.mktime(pin.release_date.timetuple())) return f'{pin.id}|{unix}|{int(pin.member)}' - - pins = sorted((p.server.items[pin] for pin in inventory.keys() - if (p.server.items[pin].is_flag() and p.server.items[pin].cost == 0)), - key=operator.attrgetter('release_date')) return '%'.join(get_string(pin) for pin in pins) -@cached(alias='default', key_builder=get_awards_string_key) async def get_awards_string(p, player_id): if player_id in p.server.penguins_by_id: inventory = p.server.penguins_by_id[player_id].inventory @@ -96,11 +85,17 @@ async def handle_buy_inventory(p, item: Item): @handlers.depends_on_packet(XTPacket('i', 'gi')) @handlers.cooldown(1) async def handle_query_player_pins(p, player_id: int): - await p.send_xt('qpp', await get_pin_string(p, player_id)) + string = p.server.cache.get(f'pins.{player_id}') + string = await get_pin_string(p, player_id) if string is None else string + p.server.cache.set(f'pins.{player_id}', string) + await p.send_xt('qpp', string) @handlers.handler(XTPacket('i', 'qpa')) @handlers.depends_on_packet(XTPacket('i', 'gi')) @handlers.cooldown(1) async def handle_query_player_awards(p, player_id: int): - await p.send_xt('qpa', await get_awards_string(p, player_id)) + string = p.server.cache.get(f'awards.{player_id}') + string = await get_awards_string(p, player_id) if string is None else string + p.server.cache.set(f'awards.{player_id}', string) + await p.send_xt('qpa', string) diff --git a/houdini/handlers/play/player.py b/houdini/handlers/play/player.py index a33c3c9..349aa6c 100644 --- a/houdini/handlers/play/player.py +++ b/houdini/handlers/play/player.py @@ -3,8 +3,6 @@ import random import time from datetime import datetime, timedelta -from aiocache import cached - from houdini import handlers from houdini.constants import ClientType from houdini.converters import SeparatorConverter @@ -14,15 +12,6 @@ from houdini.data.penguin import Penguin, PenguinMembership from houdini.handlers import Priority, XMLPacket, XTPacket -def get_player_string_key(_, p, player_id): - return f'player.{player_id}' - - -def get_mascot_string_key(_, p, mascot_id): - return f'mascot.{mascot_id}' - - -@cached(alias='default', key_builder=get_player_string_key) async def get_player_string(p, penguin_id: int): if penguin_id in p.server.penguins_by_id: return await p.server.penguins_by_id[penguin_id].string @@ -32,7 +21,6 @@ async def get_player_string(p, penguin_id: int): return string -@cached(alias='default', key_builder=get_mascot_string_key) async def get_mascot_string(p, mascot_id: int): if mascot_id in p.server.penguins_by_character_id: return await p.server.penguins_by_character_id[mascot_id].string @@ -163,13 +151,18 @@ async def handle_heartbeat(p): @handlers.handler(XTPacket('u', 'gp')) @handlers.cooldown(1) async def handle_get_player(p, penguin_id: int): - await p.send_xt('gp', await get_player_string(p, penguin_id)) + player_string = p.server.cache.get(f'player.{penguin_id}') + player_string = await get_player_string(p, penguin_id) if player_string is None else player_string + await p.send_xt('gp', player_string) @handlers.handler(XTPacket('u', 'gmo'), client=ClientType.Vanilla) @handlers.cooldown(1) async def handle_get_mascot(p, mascot_id: int): - await p.send_xt('gmo', await get_mascot_string(p, mascot_id)) + mascot_string = p.server.cache.get(f'mascot.{mascot_id}') + mascot_string = await get_mascot_string(p, mascot_id) if mascot_string is None else mascot_string + p.server.cache.set(f'mascot.{mascot_id}', mascot_string) + await p.send_xt('gmo', mascot_string) @handlers.handler(XTPacket('u', 'pbi'), client=ClientType.Vanilla) diff --git a/houdini/handlers/play/stampbook.py b/houdini/handlers/play/stampbook.py index 9f04bc5..290fdce 100644 --- a/houdini/handlers/play/stampbook.py +++ b/houdini/handlers/play/stampbook.py @@ -1,5 +1,3 @@ -from aiocache import cached - from houdini import handlers from houdini.data.penguin import Penguin from houdini.data.stamp import CoverItem, CoverStamp, PenguinStampCollection, Stamp, StampCollection @@ -7,15 +5,6 @@ from houdini.handlers import Priority, XMLPacket, XTPacket from houdini.handlers.play.navigation import handle_join_room, handle_join_server -def get_book_cover_key(_, p, player_id): - return f'book.{player_id}' - - -def get_player_stamps_key(_, p, player_id): - return f'stamps.{player_id}' - - -@cached(alias='default', key_builder=get_book_cover_key) async def get_book_cover_string(p, player_id): if player_id in p.server.penguins_by_id: player = p.server.penguins_by_id[player_id] @@ -38,7 +27,6 @@ async def get_book_cover_string(p, player_id): return '%'.join(map(str, cover_details)) -@cached(alias='default', key_builder=get_player_stamps_key) async def get_player_stamps_string(p, player_id): if player_id in p.server.penguins_by_id: stamp_inventory = p.server.penguins_by_id[player_id].stamps @@ -83,7 +71,10 @@ async def handle_add_mascot_stamp(p): @handlers.handler(XTPacket('st', 'gps')) @handlers.cooldown(1) async def handle_get_player_stamps(p, player_id: int): - await p.send_xt('gps', p.id, await get_player_stamps_string(p, player_id)) + stamps_string = p.server.cache.get(f'stamps.{player_id}') + stamps_string = await get_player_stamps_string(p, player_id) if stamps_string is None else stamps_string + p.server.cache.set(f'stamps.{player_id}', stamps_string) + await p.send_xt('gps', p.id, stamps_string) @handlers.handler(XTPacket('st', 'gmres')) @@ -105,7 +96,10 @@ async def handle_stamp_add(p, stamp: Stamp): @handlers.handler(XTPacket('st', 'gsbcd')) @handlers.cooldown() async def handle_get_book_cover(p, player_id: int): - await p.send_xt('gsbcd', await get_book_cover_string(p, player_id)) + book_string = p.server.cache.get(f'book.{player_id}') + book_string = await get_book_cover_string(p, player_id) if book_string is None else book_string + p.server.cache.set(f'book.{player_id}', book_string) + await p.send_xt('gsbcd', book_string) @handlers.handler(XTPacket('st', 'ssbcd')) @@ -160,4 +154,4 @@ async def handle_update_book_cover(p, color: int, highlight: int, pattern: int, book_modified=1).apply() stringified_cover = '%'.join(cover) - await p.server.cache.set(f'book.{p.id}', f'{color}%{highlight}%{pattern}%{icon}%{stringified_cover}') + p.server.cache.set(f'book.{p.id}', f'{color}%{highlight}%{pattern}%{icon}%{stringified_cover}') diff --git a/houdini/houdini.py b/houdini/houdini.py index e2f8af8..95ea61c 100644 --- a/houdini/houdini.py +++ b/houdini/houdini.py @@ -5,7 +5,7 @@ import sys from logging.handlers import RotatingFileHandler import aioredis -from aiocache import SimpleMemoryCache, caches +from cacheout import Cache from houdini import PenguinStringCompiler from houdini.data import db @@ -147,12 +147,7 @@ class Houdini: await self.redis.delete(f'houdini.players.{self.config.id}') await self.redis.hset(f'houdini.population', self.config.id, 0) - caches.set_config(dict(default=dict( - cache=SimpleMemoryCache, - namespace='houdini', - ttl=self.config.cache_expiry - ))) - self.cache = caches.get('default') + self.cache = Cache(maxsize=None, ttl=self.config.cache_expiry) self.client_class = Penguin self.penguin_string_compiler = PenguinStringCompiler() diff --git a/houdini/penguin.py b/houdini/penguin.py index b891086..9c42ea5 100644 --- a/houdini/penguin.py +++ b/houdini/penguin.py @@ -103,8 +103,8 @@ class Penguin(Spheniscidae, penguin.Penguin): self.logger.info(f'{self.username} added \'{item.name}\' to their clothing inventory') - await self.server.cache.delete(f'pins.{self.id}') - await self.server.cache.delete(f'awards.{self.id}') + self.server.cache.delete(f'pins.{self.id}') + self.server.cache.delete(f'awards.{self.id}') return True @@ -249,7 +249,7 @@ class Penguin(Spheniscidae, penguin.Penguin): await self.send_xt('aabs', stamp.id) self.logger.info(f'{self.username} earned stamp \'{stamp.name}\'') - await self.server.cache.delete(f'stamps.{self.id}') + self.server.cache.delete(f'stamps.{self.id}') return True diff --git a/requirements.txt b/requirements.txt index 0948455..aee65e3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,7 @@ asyncio aioredis +cacheout gino -aiocache ujson defusedxml bcrypt