import asyncio import os import sys import pkgutil import importlib from Houdini.Spheniscidae import Spheniscidae from Houdini.Penguin import Penguin from Houdini import PenguinStringCompiler import config from aiologger import Logger from aiologger.handlers.files import AsyncTimedRotatingFileHandler, RolloverInterval, AsyncFileHandler from aiologger.handlers.streams import AsyncStreamHandler import logging from logging.handlers import RotatingFileHandler import aioredis from aiocache import SimpleMemoryCache from watchdog.observers import Observer from Houdini.Data import db from Houdini.Data.Item import ItemCrumbsCollection from Houdini.Data.Igloo import IglooCrumbsCollection, FurnitureCrumbsCollection, \ LocationCrumbsCollection, FlooringCrumbsCollection from Houdini.Data.Room import RoomCrumbsCollection from Houdini.Data.Stamp import StampCrumbsCollection from Houdini.Data.Ninja import CardCrumbsCollection from Houdini.Data.Mail import PostcardCrumbsCollection from Houdini.Data.Pet import PuffleCrumbsCollection, PuffleItemCrumbsCollection try: import uvloop uvloop.install() except ImportError: uvloop = None import Houdini.Handlers from Houdini.Handlers import listeners_from_module, remove_handlers_by_module from Houdini.Events.HandlerFileEvent import HandlerFileEventHandler from Houdini.Events.PluginFileEvent import PluginFileEventHandler from Houdini.Commands import commands_from_plugin import Houdini.Plugins as Plugins class HoudiniFactory: def __init__(self, **kwargs): self.server = None self.redis = None self.config = None self.cache = None self.db = db self.peers_by_ip = {} self.server_name = kwargs['server'] self.server_config = None self.logger = None self.client_class = Spheniscidae self.penguin_string_compiler = None self.anonymous_penguin_string_compiler = None self.penguins_by_id = {} self.penguins_by_username = {} self.xt_listeners, self.xml_listeners = {}, {} self.commands = {} self.plugins = {} self.items = None self.igloos = None self.furniture = None self.locations = None self.flooring = None self.rooms = None self.stamps = None self.cards = None self.postcards = None self.puffles = None self.puffle_items = None self.spawn_rooms = None async def start(self): self.config = config self.server_config = self.config.servers[self.server_name] general_log_directory = os.path.dirname(self.server_config["Logging"]["General"]) errors_log_directory = os.path.dirname(self.server_config["Logging"]["Errors"]) if not os.path.exists(general_log_directory): os.mkdir(general_log_directory) if not os.path.exists(errors_log_directory): os.mkdir(errors_log_directory) if sys.platform != 'win32': self.logger = Logger(name='Houdini') universal_handler = AsyncTimedRotatingFileHandler( filename=self.server_config['Logging']['General'], backup_count=3, when=RolloverInterval.HOURS ) error_handler = AsyncFileHandler(filename=self.server_config['Logging']['Errors']) console_handler = AsyncStreamHandler(stream=sys.stdout) else: self.logger = logging.getLogger('Houdini') universal_handler = RotatingFileHandler(self.server_config['Logging']['General'], maxBytes=2097152, backupCount=3, encoding='utf-8') error_handler = logging.FileHandler(self.server_config['Logging']['Errors']) console_handler = logging.StreamHandler(stream=sys.stdout) log_formatter = logging.Formatter('%(asctime)s [%(levelname)-5.5s] %(message)s') error_handler.setLevel(logging.ERROR) universal_handler.setFormatter(log_formatter) console_handler.setFormatter(log_formatter) self.logger.addHandler(universal_handler) self.logger.addHandler(console_handler) self.logger.addHandler(error_handler) level = logging.getLevelName(self.server_config['Logging']['Level']) self.logger.setLevel(level) self.server = await asyncio.start_server( self.client_connected, self.server_config['Address'], self.server_config['Port'] ) await self.db.set_bind('postgresql://{}:{}@{}/{}'.format( self.config.database['Username'], self.config.database['Password'], self.config.database['Address'], self.config.database['Name'])) self.logger.info('Houdini module instantiated') self.redis = await aioredis.create_redis_pool('redis://{}:{}'.format( self.config.redis['Address'], self.config.redis['Port']), minsize=5, maxsize=10) if self.server_config['World']: await self.redis.delete('{}.players'.format(self.server_name)) await self.redis.delete('{}.population'.format(self.server_name)) self.cache = SimpleMemoryCache(namespace='houdini', ttl=self.server_config['CacheExpiry']) self.client_class = Penguin self.penguin_string_compiler = PenguinStringCompiler() self.anonymous_penguin_string_compiler = PenguinStringCompiler() PenguinStringCompiler.setup_default_builder(self.penguin_string_compiler) PenguinStringCompiler.setup_anonymous_default_builder(self.anonymous_penguin_string_compiler) self.load_handler_modules(exclude_load="Houdini.Handlers.Login.Login") self.logger.info('World server started') else: self.load_handler_modules("Houdini.Handlers.Login.Login") self.logger.info('Login server started') self.items = await ItemCrumbsCollection.get_collection() self.logger.info('Loaded {} clothing items'.format(len(self.items))) self.igloos = await IglooCrumbsCollection.get_collection() self.logger.info('Loaded {} igloos'.format(len(self.igloos))) self.furniture = await FurnitureCrumbsCollection.get_collection() self.logger.info('Loaded {} furniture items'.format(len(self.furniture))) self.locations = await LocationCrumbsCollection.get_collection() self.logger.info('Loaded {} igloo locations'.format(len(self.locations))) self.flooring = await FlooringCrumbsCollection.get_collection() self.logger.info('Loaded {} igloo flooring'.format(len(self.flooring))) self.rooms = await RoomCrumbsCollection.get_collection() self.spawn_rooms = self.rooms.get_spawn_rooms() await self.rooms.setup_tables() await self.rooms.setup_waddles() self.logger.info('Loaded {} rooms ({} spawn)'.format(len(self.rooms), len(self.spawn_rooms))) self.postcards = await PostcardCrumbsCollection.get_collection() self.logger.info('Loaded {} postcards'.format(len(self.postcards))) self.stamps = await StampCrumbsCollection.get_collection() self.logger.info('Loaded {} stamps'.format(len(self.stamps))) self.cards = await CardCrumbsCollection.get_collection() self.logger.info('Loaded {} ninja cards'.format(len(self.cards))) self.puffles = await PuffleCrumbsCollection.get_collection() self.logger.info('Loaded {} puffles'.format(len(self.puffles))) self.puffle_items = await PuffleItemCrumbsCollection.get_collection() self.logger.info('Loaded {} puffle care items'.format(len(self.puffle_items))) handlers_path = './Houdini{}Handlers'.format(os.path.sep) plugins_path = './Houdini{}Plugins'.format(os.path.sep) self.configure_observers([handlers_path, HandlerFileEventHandler], [plugins_path, PluginFileEventHandler]) self.logger.info('Listening on {}:{}'.format(self.server_config['Address'], self.server_config['Port'])) await self.load_plugins() async with self.server: await self.server.serve_forever() async def load_plugins(self): for plugin_package in self.get_package_modules(Plugins): await self.load_plugin(plugin_package) async def load_plugin(self, plugin): plugin_module, plugin_class = plugin if plugin_class not in self.server_config['Plugins']: return plugin_object = getattr(plugin_module, plugin_class)(self) if isinstance(plugin_object, Plugins.IPlugin): self.plugins[plugin_class] = plugin_object listeners_from_module(self.xt_listeners, self.xml_listeners, plugin_object) commands_from_plugin(self.commands, plugin_object) await plugin_object.ready() else: self.logger.warn('{0} plugin object doesn\'t provide the plugin interface'.format(plugin_class)) def unload_plugin(self, plugin): plugin_module, plugin_class = plugin if plugin_class in self.plugins: plugin_module_path = plugin_module.__file__ del self.plugins[plugin_class] remove_handlers_by_module(self.xt_listeners, self.xml_listeners, plugin_module_path) async def client_connected(self, reader, writer): client_object = self.client_class(self, reader, writer) await client_object.run() def load_handler_modules(self, strict_load=None, exclude_load=None): for handler_module in self.get_package_modules(Houdini.Handlers): if not (strict_load and handler_module not in strict_load or exclude_load and handler_module in exclude_load): if handler_module not in sys.modules.keys(): module = importlib.import_module(handler_module) listeners_from_module(self.xt_listeners, self.xml_listeners, module) self.logger.info('Handler modules loaded') def get_package_modules(self, package): package_modules = [] for importer, module_name, is_package in pkgutil.iter_modules(package.__path__): full_module_name = '{0}.{1}'.format(package.__name__, module_name) if is_package: subpackage_object = importlib.import_module(full_module_name, package=package.__path__) subpackage_object_directory = dir(subpackage_object) if Plugins.IPlugin.__name__ in subpackage_object_directory: package_modules.append((subpackage_object, module_name)) continue sub_package_modules = self.get_package_modules(subpackage_object) package_modules = package_modules + sub_package_modules else: package_modules.append(full_module_name) return package_modules def configure_observers(self, *observer_settings): for observer_path, observer_class in observer_settings: event_observer = Observer() event_observer.schedule(observer_class(self), observer_path, recursive=True) event_observer.start()