Merge pull request #148 from 8r2y5/feature/142

Merging PR #148, Optimalization, unit tests.

Author: kamilion

.gitignore

@@ -1,3 +1,4 @@
+.cache
 *.py[cod]
 
 # C extensions
@@ -50,3 +51,6 @@ nosetests.xml
 
 # Mac cleanup
 .DS_Store
+
+cover
+.noseids

__init__.py

@@ -1,4 +1,35 @@
 # encoding: utf-8
+import re
+
+from packets import Packets
+
+
+packet_name_regex = re.compile(r'(?P<when>on|after)_(?P<packet_name>\w+)')
+
+
+class MapOverridePacketsMethods(type):
+    ignored_methods = ('activate', 'deactivate')
+
+    def __new__(cls, name, bases, cls_dict):
+        if name != 'BasePlugin':
+            cls_dict['overridden_packets'] = {}
+            methods = (
+                key for key, value in cls_dict.iteritems()
+                if key not in cls.ignored_methods and callable(value)
+            )
+            for packet_method_name in methods:
+                packet = packet_name_regex.match(packet_method_name)
+                if packet:
+                    packet_name = packet.group('packet_name').upper()
+                    enum = getattr(Packets, packet_name, None)
+                    if enum:
+                        cls_dict['overridden_packets'].setdefault(
+                            enum.value, {}
+                        )[packet.group('when')] = packet_method_name
+
+        return super(MapOverridePacketsMethods, cls).__new__(
+            cls, name, bases, cls_dict
+        )
 
 
 class BasePlugin(object):
@@ -19,17 +50,30 @@ class BasePlugin(object):
     complain quite thoroughly.
     """
 
+    __metaclass__ = MapOverridePacketsMethods
+
     name = 'Base Plugin'
     description = 'The common class for all plugins to inherit from.'
     version = '.1'
     depends = []
+    active = False
+
+    def __init__(self, *args, **kwargs):
+        self.overridden_methods = {}
+        super(BasePlugin, self).__init__(*args, **kwargs)
+        if self.__class__.__name__ != 'BasePlugin':
+            for packet, when_dict in self.overridden_packets.iteritems():
+                self.overridden_methods.setdefault(packet, {})
+                for when, packet_name in when_dict.iteritems():
+                    self.overridden_methods[packet][when] = getattr(
+                        self, packet_name
+                    )
 
     def activate(self):
         """
         Called when the plugins are activated, do any setup work here.
         """
         self.active = True
-        self.logger.debug('%s plugin object activated.', self.name)
         return True
 
     def deactivate(self):
@@ -38,7 +82,6 @@ def deactivate(self):
         as it is likely that the plugin will soon be destroyed.
         """
         self.active = False
-        self.logger.debug('%s plugin object deactivated', self.name)
         return True
 
     def on_protocol_version(self, data):
@@ -371,11 +414,14 @@ def after_fly_ship(self, data):
     def after_central_structure_update(self, data):
         return True
 
-    def __repr__(self):
-        return '<Plugin instance: {} (version {})>'.format(
+    def __unicode__(self):
+        return u'<Plugin instance: {} (version {})>'.format(
             self.name, self.version
         )
 
+    def __str__(self):
+        return self.__unicode__()
+
 
 class CommandNameError(Exception):
     """

base_plugin.py

@@ -5,22 +5,16 @@
 import sys
 import os
 
-from utility_functions import recursive_dictionary_update, path
-
-
-class Singleton(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(
-                *args, **kwargs
-            )
-        return cls._instances[cls]
+from utility_functions import (
+    recursive_dictionary_update,
+    path,
+    Singleton
+)
 
 
 class ConfigurationManager(object):
     __metaclass__ = Singleton
+
     logger = logging.getLogger('starrypy.config.ConfigurationManager')
     log_format = logging.Formatter(
         '%(asctime)s - %(levelname)s - %(name)s # %(message)s'

config.py

@@ -52,6 +52,7 @@ def __init__(self, factory, base_class=BasePlugin):
 
         :param base_class: The base class to use while searching for plugins.
         """
+        self.packets = {}
         self.plugins = {}
         self.plugin_classes = {}
         self.plugins_waiting_to_load = {}
@@ -65,6 +66,7 @@ def __init__(self, factory, base_class=BasePlugin):
         self.plugin_dir = path.child(self.config.plugin_path)
         sys.path.append(self.plugin_dir.path)
 
+    def prepare(self):
         self.load_plugins(
             [
                 'core.admin_commands_plugin',
@@ -87,23 +89,18 @@ def __init__(self, factory, base_class=BasePlugin):
 
     def installed_plugins(self):
         """
-        Get list of all plugins in the plugin_dir.
-
-        :param name: None
-        :return: Array of plugin names.
+        Returns list of all plugins in the plugin_dir.
         """
-        installed_plugins = filter(
-            None,
+        return filter(
+            lambda name: not (name is None or name == 'core'),
             (
-                self.get_plugin_name_from_file(f)
-                for f in self.plugin_dir.globChildren('*')
+                self.get_plugin_name_from_file(plugin_file)
+                for plugin_file in self.plugin_dir.globChildren('*')
             )
         )
 
-        # don't list core as a plugin
-        return filter(lambda name: name != 'core', installed_plugins)
-
-    def get_plugin_name_from_file(self, f):
+    @staticmethod
+    def get_plugin_name_from_file(f):
         if f.isdir():
             return f.basename()
         else:
@@ -114,7 +111,6 @@ def import_plugin(self, name):
         Import plugin that has the given name, and is a subclass of base_class.
 
         :param name: The name of the plugin to import.
-        :return: None
         """
         try:
             mod = __import__(name, globals(), locals(), [], 0)
@@ -221,6 +217,7 @@ def activate_plugins(self, plugins, dependencies):
                     for p in plugin_deps:
                         self.plugin_classes[plugin.name].plugins[p.name] = p
                 self.plugins[plugin.name].activate()
+                self.map_plugin_packets(plugin)
             except FatalPluginError as e:
                 self.logger.critical(
                     'A plugin reported a fatal error. Error: %s', str(e)
@@ -236,8 +233,9 @@ def deactivate_plugins(self):
                     'A plugin reported a fatal error. Error: %s', str(e)
                 )
                 raise
+            self.de_map_plugin_packets(plugin)
 
-    def do(self, protocol, command, data):
+    def do(self, protocol, when, data):
         """
         Runs a command across all currently loaded plugins.
 
@@ -248,28 +246,52 @@ def do(self, protocol, command, data):
         :return: Whether or not all plugins returned True or None.
         :rtype: bool
         """
-        return_values = []
         if protocol is None:
             return True
-        for plugin in self.plugins.itervalues():
+
+        return_values = []
+        packets = self.packets.get(data.id, {}).get(when, {}).itervalues()
+        for plugin, packet_method in packets:
             try:
-                if not plugin.active:
-                    continue
                 plugin.protocol = protocol
-                res = getattr(plugin, command, lambda _: True)(data)
-                if res is None:
+                res = packet_method(data)
+                if res is False:
+                    return False
+                elif res is None:
                     res = True
+
                 return_values.append(res)
             except:
                 self.logger.exception(
                     'Error in plugin %s with function %s.',
-                    str(plugin), command
+                    str(plugin), packet_method.__name__
                 )
         return all(return_values)
 
     def die(self):
         self.deactivate_plugins()
 
+    def map_plugin_packets(self, plugin):
+        """
+        Maps plugin overridden packets ready to use in do method.
+        """
+        for packet_id, when_dict in plugin.overridden_methods.iteritems():
+            for when, packet_method in when_dict.iteritems():
+                self.packets.setdefault(
+                    packet_id, {}
+                ).setdefault(
+                    when, {}
+                )[plugin.name] = (plugin, packet_method)
+
+    def de_map_plugin_packets(self, plugin):
+        """
+        Removes plugin overridden packets method from packets dictionary.
+        """
+        for packet_id, when_dict in self.packets.iteritems():
+            for when, plugins in when_dict.iteritems():
+                if plugin.name in plugins:
+                    plugins.pop(plugin.name)
+
 
 def route(func):
     """
@@ -278,18 +300,15 @@ def route(func):
     logger = logging.getLogger('starrypy.plugin_manager.route')
 
     def wrapped_function(self, data):
-        name = func.__name__
-        on = 'on_%s' % name
-        after = 'after_%s' % name
-        res = self.plugin_manager.do(self, on, data)
+        res = self.plugin_manager.do(self, 'on', data)
         if res:
             res = func(self, data)
             d = deferLater(
                 reactor,
                 .01,
                 self.plugin_manager.do,
                 self,
-                after,
+                'after',
                 data
             )
             d.addErrback(print_this_defered_failure)

plugin_manager.py

@@ -9,7 +9,7 @@ class AdminMessenger(BasePlugin):
     """
     Adds support to message moderators/admins/owner with a @@ prefixed message.
     """
-    name = "admin_messenger"
+    name = 'admin_messenger'
     depends = ['player_manager_plugin']
 
     def activate(self):
@@ -26,48 +26,56 @@ def on_chat_sent(self, data):
             return False
         return True
 
-    def message_admins(self, message):
-        now = datetime.now()
+    def add_timestamp(self, add_normalizer=False):
         if self.config.chattimestamps:
-            timestamp = "^red;<{}> ^yellow;".format(now.strftime("%H:%M"))
+            now = datetime.now()
+            timestamp = '^red;<{}> '.format(now.strftime('%H:%M'))
+            if add_normalizer:
+                return '{}^yellow;'.format(timestamp)
+            return timestamp
         else:
-            timestamp = ""
+            return ''
+
+    def message_admins(self, message):
+        timestamp = self.add_timestamp(add_normalizer=True)
+        message = message.message[2:].decode('utf-8')
+
         for protocol in self.factory.protocols.itervalues():
             if protocol.player.access_level >= UserLevels.MODERATOR:
                 protocol.send_chat_message(
-                    "{}{}ADMIN: ^yellow;<{}^yellow;> {}{}".format(
-                        timestamp,
-                        self.config.colors["moderator"],
-                        self.protocol.player.colored_name(self.config.colors),
-                        self.config.colors["moderator"],
-                        message.message[2:].decode("utf-8")
+                    '{timestamp}{moderator_colors}'
+                    'ADMIN: ^yellow;<{player_colors}^yellow;> '
+                    '{moderator_colors}{message}'.format(
+                        timestamp=timestamp,
+                        moderator_colors=self.config.colors['moderator'],
+                        player_colors=(
+                            self.protocol.player.colored_name(
+                                self.config.colors
+                            )
+                        ),
+                        message=message
                     )
                 )
                 self.logger.info(
-                    "Received an admin message from %s. Message: %s",
-                    self.protocol.player.name,
-                    message.message[2:].decode("utf-8")
+                    'Received an admin message from %s. Message: %s',
+                    self.protocol.player.name, message
                 )
 
     @permissions(UserLevels.ADMIN)
     def broadcast_message(self, message):
-        now = datetime.now()
-        if self.config.chattimestamps:
-            timestamp = "^red;<{}> ".format(now.strftime("%H:%M"))
-        else:
-            timestamp = ""
+        timestamp = self.add_timestamp()
 
         for protocol in self.factory.protocols.itervalues():
             protocol.send_chat_message(
-                "{}{}BROADCAST: ^red;{}{}".format(
+                '{}{}BROADCAST: ^red;{}{}'.format(
                     timestamp,
-                    self.config.colors["admin"],
-                    message.message[3:].decode("utf-8").upper(),
-                    self.config.colors["default"]
+                    self.config.colors['admin'],
+                    message.message[3:].decode('utf-8').upper(),
+                    self.config.colors['default']
                 )
             )
             self.logger.info(
-                "Broadcast from %s. Message: %s",
+                'Broadcast from %s. Message: %s',
                 self.protocol.player.name,
-                message.message[3:].decode("utf-8").upper()
+                message.message[3:].decode('utf-8').upper()
             )