Register plugin exceptions as PluginExit events.

refs #149

Author: GraylinKim

sc2reader/engine/engine.py

@@ -102,6 +102,15 @@ def handleAbilityEvent(self, event, replay):
         replay::
 
             code, details = replay.plugins['MyPlugin']
+
+        If your plugin depends on another plugin, it is a good idea to implement handlePluginExit
+        and be alerted if the plugin that you require fails. This way you can exit gracefully. You
+        can also check to see if the plugin name is in ``replay.plugin_failures``::
+
+            if 'RequiredPlugin' in replay.plugin_failures:
+                code, details = replay.plugins['RequiredPlugin']
+                message = "RequiredPlugin failed with code: {0}. Cannot continue.".format(code)
+                yield PluginExit(self, code=1, details=dict(msg=message))
     """
     def __init__(self, plugins=[]):
         self._plugins = list()
@@ -123,8 +132,11 @@ def run(self, replay):
         # remove them from this list and regenerate event handlers.
         plugins = list(self._plugins)
 
-        # Create a dict for storing plugin exit codes and details
-        replay.plugins = dict()
+        # Create a dict for storing plugin exit codes and details.
+        replay.plugin_result = replay.plugins = dict()
+
+        # Create a list storing replay.plugins keys for failures.
+        replay.plugin_failures = list()
 
         # Fill event event queue with the replay events, bookmarked by Init and End events.
         event_queue = collections.deque()
@@ -141,8 +153,9 @@ def run(self, replay):
                 # Remove the plugin and reset the handlers.
                 plugins.remove(event.plugin)
                 handlers.clear()
-                replay.plugins[event.plugin.name] = (event.code, event.details)
-                continue
+                replay.plugin_result[event.plugin.name] = (event.code, event.details)
+                if event.code != 0:
+                    replay.plugin_failures.append(event.plugin.name)
 
             # If we haven't compiled a list of handlers for this event yet, do so!
             if event.name not in handlers:
@@ -152,19 +165,31 @@ def run(self, replay):
                 event_handlers = handlers[event.name]
 
             # Events have the option of yielding one or more additional events
-            # which get processed after the current event finishes.
-            new_events = list()
+            # which get processed after the current event finishes. The new_events
+            # batch is constructed in reverse order because extendleft reverses
+            # the order again with a series of appendlefts.
+            new_events = collections.deque()
             for event_handler in event_handlers:
-                new_events.extend(event_handler(event, replay) or [])
-
-            # extendleft does a series of appendlefts and reverses the order so we
-            # need to reverse the list first to have them added in order.
+                try:
+                    for new_event in (event_handler(event, replay) or []):
+                        if new_event.name == 'PluginExit':
+                            new_events.append(new_event)
+                            break
+                        else:
+                            new_events.appendleft(new_event)
+                except Exception as e:
+                    if event_handler.im_self.name in ['ContextLoader']:
+                        # Certain built in plugins should probably still cause total failure
+                        raise  # Maybe??
+                    else:
+                        new_event = PluginExit(event_handler.im_self, code=1, details=dict(error=e))
+                        new_events.append(new_event)
             event_queue.extendleft(new_events)
 
-        # For any plugins that didn't yield a PluginExit event, record a successful
-        # completion.
+        # For any plugins that didn't yield a PluginExit event or throw unexpected exceptions,
+        # record a successful completion.
         for plugin in plugins:
-            replay.plugins[plugin.name] = (0, dict())
+            replay.plugin_result[plugin.name] = (0, dict())
 
     def _get_event_handlers(self, event, plugins):
         return sum([self._get_plugin_event_handlers(plugin, event) for plugin in plugins], [])
@@ -194,35 +219,3 @@ def _has_event_handler(self, plugin, event):
 
     def _get_event_handler(self, plugin, event):
         return getattr(plugin, 'handle'+event.name, None)
-
-
-if __name__ == '__main__':
-    from sc2reader.events import UserOptionsEvent, GameStartEvent, PlayerLeaveEvent
-
-    class TestEvent(object):
-        name = 'TestEvent'
-
-        def __init__(self, source):
-            self.source = source
-
-    class TestPlugin(object):
-        yields = TestEvent
-
-        def handleInitGame(self, event, replay,):
-            yield TestEvent(event.name)
-
-        def handleTestEvent(self, event, replay):
-            print(event.source)
-
-        def handleGameStartEvent(self, event, replay):
-            yield TestEvent(event.name)
-
-        def handleEndGame(self, event, replay):
-            yield TestEvent(event.name)
-
-    class TestReplay(object):
-        events = [UserOptionsEvent, UserOptionsEvent, GameStartEvent, PlayerLeaveEvent]
-
-    engine = GameEngine()
-    engine.register_plugin(TestPlugin())
-    events = engine.run(TestReplay)

test_replays/test_all.py

@@ -362,5 +362,61 @@ def test_replay_event_order(self):
         replay = sc2reader.load_replay("test_replays/event_order.SC2Replay")
 
 
+class TestGameEngine(unittest.TestCase):
+    class TestEvent(object):
+        name='TestEvent'
+        def __init__(self, value):
+            self.value = value
+        def __str__(self):
+            return self.value
+
+    class TestPlugin1(object):
+        name = 'TestPlugin1'
+
+        def handleInitGame(self, event, replay):
+            yield TestGameEngine.TestEvent('b')
+            yield TestGameEngine.TestEvent('c')
+
+        def handleTestEvent(self, event, replay):
+            print("morestuff")
+            if event.value == 'd':
+                yield sc2reader.engine.PluginExit(self, code=1, details=dict(msg="Fail!"))
+            else:
+                yield TestGameEngine.TestEvent('d')
+
+        def handleEndGame(self, event, replay):
+            yield TestGameEngine.TestEvent('g')
+
+    class TestPlugin2(object):
+        name = 'TestPlugin2'
+        def handleInitGame(self, event, replay):
+            replay.engine_events = list()
+
+        def handleTestEvent(self, event, replay):
+            replay.engine_events.append(event)
+
+        def handlePluginExit(self, event, replay):
+            yield TestGameEngine.TestEvent('e')
+
+        def handleEndGame(self, event, replay):
+            yield TestGameEngine.TestEvent('f')
+
+    class MockReplay(object):
+        def __init__(self, events):
+            self.events = events
+
+    def test_plugin1(self):
+        engine = sc2reader.engine.GameEngine()
+        engine.register_plugin(self.TestPlugin1())
+        engine.register_plugin(self.TestPlugin2())
+        replay = self.MockReplay([self.TestEvent('a')])
+        engine.run(replay)
+        self.assertEqual(''.join(str(e) for e in replay.engine_events), 'bdecaf')
+        self.assertEqual(replay.plugin_failures, ['TestPlugin1'])
+        self.assertEqual(replay.plugin_result['TestPlugin1'], (1, dict(msg="Fail!")))
+        self.assertEqual(replay.plugin_result['TestPlugin2'], (0, dict()))
+
+
+
 if __name__ == '__main__':
     unittest.main()