allow execute terminal as main process

setup.py

 
 setup(
     name='synergine2',
-    version='1.0.1',
+    version='1.0.2',
     description='Subject focus simulation framework',
     author='Bastien Sevajol',
     author_email='sevajol.bastien@gmail.com',

synergine2/core.py

 # coding: utf-8
 import time
 
+from multiprocessing import Queue
+
 from synergine2.base import BaseObject
 from synergine2.config import Config
 from synergine2.cycle import CycleManager
 from synergine2.log import SynergineLogger
 from synergine2.simulation import Simulation
 from synergine2.terminals import TerminalManager
+from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 from synergine2.utils import time_it
 
         self.terminal_manager = terminal_manager or TerminalManager(config, logger, [])
         self._loop_delta = 1./cycles_per_seconds
         self._current_cycle_start_time = None
+        self._continue = True
+        self.main_process_terminal = None  # type: Terminal
 
-    def run(self):
+    def run(
+        self,
+        from_terminal: Terminal=None,
+        from_terminal_input_queue: Queue=None,
+        from_terminal_output_queue: Queue=None,
+    ):
         self.logger.info('Run core')
         try:
+            # Execute terminal in main process if needed
+            if not from_terminal:
+                self.main_process_terminal \
+                    = self.terminal_manager.get_main_process_terminal()
+                if self.main_process_terminal:
+                    self.logger.info(
+                        'The "{}" terminal have to be the main process'
+                        ', start it now'.format(
+                            self.main_process_terminal.__class__.__name__,
+                        ),
+                    )
+                    self.main_process_terminal.execute_as_main_process(self)
+                    return
+            else:
+                # A terminal is main process, so we have to add it's queues to terminal
+                # manager
+                self.terminal_manager.inputs_queues[from_terminal] \
+                    = from_terminal_input_queue
+                self.terminal_manager.outputs_queues[from_terminal] \
+                    = from_terminal_output_queue
+
             self.terminal_manager.start()
 
             start_package = TerminalPackage(
             self.logger.info('Send start package to terminals')
             self.terminal_manager.send(start_package)
 
-            while True:
+            while self._continue:
                 self._start_cycle()
 
                 events = []

synergine2/terminals.py

 # coding: utf-8
 import collections
+import typing
 from copy import copy
 from multiprocessing import Queue
 from multiprocessing import Process
 import time
 
 from synergine2.base import BaseObject
+from synergine2.exceptions import SynergineException
 from synergine2.share import shared
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
 from synergine2.simulation import Subject
 from synergine2.simulation import Event
 
+if typing.TYPE_CHECKING:
+    from synergine2.core import Core
+
 STOP_SIGNAL = '__STOP_SIGNAL__'
 
 
     # List of subscribed Event classes. Terminal will not receive events
     # who are not instance of listed classes
     subscribed_events = [Event]
+    # Permit to execute terminal in main process, only one terminal can use this
+    main_process = False
 
     def __init__(
         self,
         self.cycle_events = []
         self.event_handlers = collections.defaultdict(list)
         self.asynchronous = asynchronous
+        self.core_process = None  # type: Process
 
     def accept_event(self, event: Event) -> bool:
         for event_class in self.subscribed_events:
         self._output_queue = output_queue
         self.run()
 
+    def execute_as_main_process(self, core: 'Core') -> None:
+        """
+        This method is called when the terminal have to be the main process. It will
+        create a process with the run of core and make it's job here.
+        """
+        output_queue = Queue()
+        input_queue = Queue()
+
+        self.logger.info('Start core in a process')
+        self.core_process = Process(target=core.run, kwargs=dict(
+            from_terminal=self,
+            from_terminal_input_queue=output_queue,
+            from_terminal_output_queue=input_queue,
+        ))
+        self.core_process.start()
+
+        # Core is started, continue this terminal job
+        self.logger.info('Core started, continue terminal job')
+        self.start(input_queue=input_queue, output_queue=output_queue)
+
     def run(self):
         """
         Override this method to create your daemon terminal
         self.outputs_queues = {}
         self.inputs_queues = {}
 
+    def get_main_process_terminal(self) -> typing.Optional[Terminal]:
+        main_process_terminals = [t for t in self.terminals if t.main_process]
+        if main_process_terminals:
+            if len(main_process_terminals) > 1:
+                raise SynergineException('There is more one main process terminal !')
+            return main_process_terminals[0]
+        return None
+
     def start(self) -> None:
         self.logger.info('Start terminals')
-        for terminal in self.terminals:
-            # TODO: logs
+        # We exclude here terminal who is run from main process
+        terminals = [t for t in self.terminals if not t.main_process]
+        for terminal in terminals:
             output_queue = Queue()
             self.outputs_queues[terminal] = output_queue
 

synergine2_cocos2d/gui.py

         self.terminal = terminal
         self.cycle_duration = self.config.resolve('core.cycle_duration')
 
-        cocos.director.director.init(
+        cocos.director.\
+            director.init(
             width=640,
             height=480,
             vsync=True,

tests/test_terminals.py

 # coding: utf-8
 import time
 
+import pytest
+
 from synergine2.config import Config
+from synergine2.core import Core
+from synergine2.cycle import CycleManager
 from synergine2.log import SynergineLogger
 from synergine2.simulation import Event
+from synergine2.simulation import Simulation
+from synergine2.simulation import Subjects
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 from synergine2.terminals import TerminalManager
         assert AnOtherEvent == type(packages[1].events[0])
 
         terminals_manager.stop()  # TODO pytest must execute this if have fail
+
+    @pytest.mark.skip(reason="Buggy ! Never terminate, all processes closed ?")
+    def test_terminal_as_main_process(self):
+        config = Config()
+        logger = SynergineLogger('test')
+        simulation = Simulation(config)
+        simulation.subjects = Subjects(simulation=simulation)
+        cycle_manager = CycleManager(
+            config=config,
+            logger=logger,
+            simulation=simulation,
+        )
+
+        class MyMainTerminal(Terminal):
+            main_process = True
+
+        terminal = MyMainTerminal(config, logger)
+
+        class Terminated(Exception):
+            pass
+
+        class MyCore(Core):
+            def _end_cycle(self):
+                self._continue = False
+
+        core = MyCore(
+            config=config,
+            logger=logger,
+            simulation=simulation,
+            cycle_manager=cycle_manager,
+            terminal_manager=TerminalManager(
+                config=config,
+                logger=logger,
+                terminals=[terminal],
+            ),
+        )
+        core.run()
+        pass