source: geniuswebcore/geniusweb/simplerunner/Runner.py@ 100

import json
import logging
from pathlib import Path
import sys
import time
import traceback
from typing import List, Optional

from pyson.ObjectMapper import ObjectMapper
from tudelft.utilities.listener.Listener import Listener
from tudelft_utilities_logging.Reporter import Reporter

from geniusweb.events.ProtocolEvent import ProtocolEvent
from geniusweb.protocol.CurrentNegoState import CurrentNegoState
from geniusweb.protocol.NegoProtocol import NegoProtocol
from geniusweb.protocol.NegoSettings import NegoSettings
from geniusweb.protocol.NegoState import NegoState
from geniusweb.simplerunner.ClassPathConnectionFactory import ClassPathConnectionFactory


class Runner:
        '''
        A simple tool to run a negotiation stand-alone, without starting the servers.
        All referred files and classes need to be stored locally (or be in the
        dependency list if you use maven).
        <p>
        <em>IMPORTANT</em> SimpleRunner has a number of restrictions, compared to a
        run using a runserver and partyserver
        <ul>
        <li>With stand-alone runner, your parties are run together in a single
        classloader. The main implication is that there may arise version conflicts
        between parties.
        <li>Stand-alone runner does NOT enforce the time deadline. Parties may
        continue running indefinitely and thus bog down the JVM and stalling
        tournaments.
        </ul>
        '''

        _properlyStopped:bool = False
        _LOOPTIME = 200  # ms
        _FINALWAITTIME = 5000  # ms

        def __init__(self, settings:NegoSettings ,
                        connectionfactory:ClassPathConnectionFactory , logger:Reporter ,
                        maxruntime:int):
                '''
                @param settings          the {@link NegoSettings}
                @param connectionfactory the {@link ProtocolToPartyConnFactory}
                @param logger            the {@link Reporter} to log problems
                @param maxruntime        limit in millisecs. Ignored if 0
                '''
                if settings == None  or connectionfactory == None:
                        raise ValueError("Arguments must be not null");
                self._settings = settings;
                self._log = logger;
                self._protocol = settings.getProtocol(self._log);
                self._connectionfactory = connectionfactory;
                self._maxruntime = maxruntime;
                self._jackson = ObjectMapper()

        def isProperlyStopped(self) -> bool:
                '''
                @return true if the runner has finished
                '''
                return self._properlyStopped

        def run(self):
                this = self

                class protocolListener(Listener[ProtocolEvent]):

                        def notifyChange(self, evt: ProtocolEvent):
                                this._handle(evt)

                self._protocol.addListener(protocolListener())
                self._protocol.start(self._connectionfactory)
                remainingtime = self._maxruntime;
                while not self._properlyStopped and  (self._maxruntime == 0 or remainingtime > 0):
                        time.sleep(self._LOOPTIME / 1000.)
                        remainingtime -= self._LOOPTIME
                self._log.log(logging.INFO, "Waiting for connection closure")

                remainingtime = self._FINALWAITTIME;
                while remainingtime > 0 and\
                        len(self._connectionfactory.getOpenConnections()) != 0:
                                time.sleep(self._LOOPTIME / 1000.)
                                remainingtime -= self._LOOPTIME
                        
                openconn = self._connectionfactory.getOpenConnections()
                if len(openconn) != 0:
                        self._log.log(logging.WARNING, "Connections " + str(openconn)\
                                        +" did not close properly at end of run")
                self._log.log(logging.INFO, "end run")

        def _handle(self, evt:ProtocolEvent):
                if isinstance(evt , CurrentNegoState) and \
                        evt.getState().isFinal(1000 * time.time()):
                                self._stop()

        def _stop(self):
                self._logFinal(logging.INFO, self._protocol.getState())
                self._properlyStopped = True

        def _logFinal(self, level:int , state: NegoState):
                '''
                Separate so that we can intercept this when mocking, as this will crash
                on mocks because {@link #jackson} can not handle mocks.
                
                @param level the log {@link Level}, eg logging.WARNING
                @param state the {@link NegoState} to log
                '''
                try:
                        self._log.log(level, "protocol ended normally: "
                                        +json.dumps(self._jackson.toJson(self._protocol.getState())))
                except Exception as e:  # catch json issues
                        traceback.print_exc()

        def getProtocol(self) -> NegoProtocol:
                '''
                @return protocol that runs/ran the session.
                '''
                return self._protocol