source: geniuswebcore/geniusweb/simplerunner/NegoRunner.py@ 81

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 StdOutReporter (Reporter):
        def log(self, level:int , msg:str, exc:Optional[BaseException]=None):
                if level >= logging.WARNING :
                        print(logging.getLevelName(level) + ":" + msg, file=sys.stderr)
                else:
                        print(logging.getLevelName(level) + ":" + msg)


class NegoRunner:
        '''
        WARNING DO NOT USE. NOT WORKING YET. 
        
        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

        @staticmethod
        def main( args:List[str]) :
                '''
                The main runner
                
                @param args should have 1 argument, the settings.json file to be used.
                @throws IOException if problem occurs
                '''
                if len(args) != 1:
                        NegoRunner.showusage()
                        return;
                
                serialized = Path(args[0]).read_text("utf-8")
                settings:NegoSettings  = ObjectMapper().parse(json.loads(serialized),
                                                NegoSettings) #type:ignore

                runner = NegoRunner(settings,
                                ClassPathConnectionFactory(), StdOutReporter(), 0)
                runner.run()

        @staticmethod
        def showusage():
                print("GeniusWeb stand-alone runner.")
                print("first argument should be <settings.json>.")
                print("The settings.json file should contain the NegoSettings.")
                print("See the settings.json example file and the GeniusWeb wiki pages. ")

        

if __name__ == '__main__':   
        NegoRunner.main([sys.argv[1]])