def init_jvm(): global gateway # global javaChild """Initializes the Java virtual machine (JVM). """ if gateway != None: return folder_suffix = [ u'{0}', u'{0}{1}bin', u'{0}{1}jhannanum-0.8.4.jar', u'{0}{1}kkma-2.0.jar', u'{0}{1}komoran-2.4-e.jar', u'{0}{1}shineware-common-2.0.jar', u'{0}{1}shineware-ds-1.0.jar', u'{0}{1}snakeyaml-1.12.jar', u'{0}{1}scala-library-2.11.4.jar', u'{0}{1}twitter-korean-text-2.4.3.jar', u'{0}{1}twitter-text-1.10.1.jar', u'{0}{1}*' ] javadir = u'%s%sjava' % (utils.installpath, os.sep) args = [javadir, os.sep] classpath = os.pathsep.join(f.format(*args) for f in folder_suffix) py4jpath = u'{0}{1}py4j-0.9.2.jar'.format(*args) port = launch_gateway(jarpath=py4jpath, classpath=classpath, javaopts=['-Dfile.encoding=UTF8', '-ea', '-Xmx768m']) # javaChild = Popen(['java', # '-cp', classpath, # '-Dfile.encoding=UTF8', # '-ea', '-Xmx768m', # 'kr.lucypark.py4j.KonlpyGateway']); print("Initializing JAVA frameworks...") time.sleep(1) jvm_e = None for i in range(0, 10): try: time.sleep(1) gateway = JavaGateway(gateway_parameters=GatewayParameters( port=port)) except Exception as e: gateway = None jvm_e = e continue break if gateway == None: if jvm_e != None: raise jvm_e raise JvmError("Could not connect to JVM. unknown error") print("JAVA frameworks initialized.") atexit.register(shutdown_jvm)
def get_gateway(): """Get Py4J JavaGateway that can work with both sides. """ # Do some magic here to determine if we are running old or new py4j # versions. from py4j.java_gateway import JavaGateway if has_pinned_thread(): from py4j.java_gateway import ( GatewayParameters, CallbackServerParameters) return JavaGateway( gateway_parameters=GatewayParameters(), callback_server_parameters=CallbackServerParameters()) else: return JavaGateway(start_callback_server=True)
def __init__(self, port): super(HakoAgent, self).__init__(characters.Bomber) self.path = os.path.abspath("agents/hako/BBMServer" + str(port) + ".jar") self.server_thread = Thread(target=self.start_server, daemon=True) self.server_thread.start() time.sleep(5) self._pid = os.getpid() self._me = -1 self._caller_id = random.randint(1000000, 10000000) # print("MyAgent.__init__, pid={}, caller_id={}, me={}".format(self._pid, self._caller_id, self._me), flush=True) self.gateway = JavaGateway(gateway_parameters=GatewayParameters(port=port)) self._addition_app = self.gateway.entry_point self._addition_app.init_agent(self._pid, self._caller_id, self._me) print("agent initialized", flush=True)
def get_instance(self): if not (self.instance is None): return self.instance if self.launch: self.port, token = launch_gateway(enable_auth=True, die_on_exit=True, classpath=get_Warp10_jar_path()) if self.verbose: print('Local gateway launched on port ' + str(self.port)) instance = JavaGateway(gateway_parameters=GatewayParameters( port=self.port, auto_convert=True, auth_token=token)) else: instance = JavaGateway(gateway_parameters=GatewayParameters( self.addr, self.port, auto_convert=True, auth_token=self.auth_token)) if self.verbose: print('Establish connection with a gateway at ' + self.addr + ":" + str(self.port)) return instance
def get_gateway(): # type: () -> JavaGateway global _gateway global _lock with _lock: if _gateway is None: # if Java Gateway is already running if 'PYFLINK_GATEWAY_PORT' in os.environ: gateway_port = int(os.environ['PYFLINK_GATEWAY_PORT']) gateway_param = GatewayParameters(port=gateway_port, auto_convert=True) _gateway = JavaGateway(gateway_parameters=gateway_param) else: _gateway = launch_gateway() return _gateway
def launch_gateway(): # type: () -> JavaGateway """ launch jvm gateway """ FLINK_HOME = _find_flink_home() # TODO windows support on_windows = platform.system() == "Windows" if on_windows: raise Exception("Windows system is not supported currently.") script = "./bin/pyflink-gateway-server.sh" command = [os.path.join(FLINK_HOME, script)] command += ['-c', 'org.apache.flink.python.client.PythonGatewayServer'] # Create a temporary directory where the gateway server should write the connection information. conn_info_dir = tempfile.mkdtemp() try: fd, conn_info_file = tempfile.mkstemp(dir=conn_info_dir) os.close(fd) os.unlink(conn_info_file) env = dict(os.environ) env["_PYFLINK_CONN_INFO_PATH"] = conn_info_file def preexec_func(): # ignore ctrl-c / SIGINT signal.signal(signal.SIGINT, signal.SIG_IGN) # Launch the Java gateway. # We open a pipe to stdin so that the Java gateway can die when the pipe is broken p = Popen(command, stdin=PIPE, preexec_fn=preexec_func, env=env) while not p.poll() and not os.path.isfile(conn_info_file): time.sleep(0.1) if not os.path.isfile(conn_info_file): raise Exception( "Java gateway process exited before sending its port number") with open(conn_info_file, "rb") as info: gateway_port = struct.unpack("!I", info.read(4))[0] finally: shutil.rmtree(conn_info_dir) # Connect to the gateway gateway = JavaGateway(gateway_parameters=GatewayParameters( port=gateway_port, auto_convert=True)) return gateway
def start_jvm(option, classpath): import os global GATEWAY jarpath = None for path in classpath: if 'py4j' in path: jarpath = path break port = launch_gateway(jarpath=jarpath, classpath=os.pathsep.join(classpath), javaopts=option) GATEWAY = JavaGateway(gateway_parameters=GatewayParameters(port=port, auto_close=True), callback_server_parameters=CallbackServerParameters()) return is_jvm_running()
def launch_gateway(): # type: () -> JavaGateway """ launch jvm gateway """ if is_launch_gateway_disabled(): raise Exception( "It's launching the PythonGatewayServer during Python UDF execution " "which is unexpected. It usually happens when the job codes are " "in the top level of the Python script file and are not enclosed in a " "`if name == 'main'` statement.") args = ['-c', 'org.apache.flink.client.python.PythonGatewayServer'] submit_args = os.environ.get("SUBMIT_ARGS", "local") args += shlex.split(submit_args) # Create a temporary directory where the gateway server should write the connection information. conn_info_dir = tempfile.mkdtemp() try: fd, conn_info_file = tempfile.mkstemp(dir=conn_info_dir) os.close(fd) os.unlink(conn_info_file) env = dict(os.environ) env["_PYFLINK_CONN_INFO_PATH"] = conn_info_file p = launch_gateway_server_process(env, args) while not p.poll() and not os.path.isfile(conn_info_file): time.sleep(0.1) if not os.path.isfile(conn_info_file): raise Exception( "Java gateway process exited before sending its port number") with open(conn_info_file, "rb") as info: gateway_port = struct.unpack("!I", info.read(4))[0] finally: shutil.rmtree(conn_info_dir) # Connect to the gateway gateway = JavaGateway(gateway_parameters=GatewayParameters( port=gateway_port, auto_convert=True), callback_server_parameters=CallbackServerParameters( port=0, daemonize=True, daemonize_connections=True)) return gateway
def __ensureGatewayInit(cls, gatewayPort, gatewaySecret, driver): with cls._lock: if not cls._gateway: # Spark 1.6 and Spark 2 are using later verions of py4j (0.9 and 0.10+ respectively), # which has better control on gateway client and callback server using # GatewayParameters and CallbackServerParameters. Try to use those, # as it'll be less hacky (it's still a bit hacky for Spark 1.6, see below) try: from py4j.java_gateway import GatewayParameters, CallbackServerParameters callbackServerParams = CallbackServerParameters( port=0, daemonize=True, daemonize_connections=True) if driver else None gateway = JavaGateway( gateway_parameters=GatewayParameters( port=gatewayPort, auto_convert=True, auth_token=gatewaySecret), callback_server_parameters=callbackServerParams) except: from py4j.java_gateway import CallbackServer, GatewayClient gateway = JavaGateway( gateway_client=GatewayClient(port=gatewayPort), auto_convert=True) cls._onDemandCallback = True java_import(gateway.jvm, "io.cdap.cdap.app.runtime.spark.*") java_import(gateway.jvm, "io.cdap.cdap.app.runtime.spark.python.*") if driver and not cls._onDemandCallback: # For py4j 0.10+ (used by Spark 2.0), use the official API to set set callback port on the gateway server if "get_callback_server" in dir(gateway): callbackPort = gateway.get_callback_server( ).get_listening_port() gateway.jvm.SparkPythonUtil.setGatewayCallbackPort( gateway.java_gateway_server, callbackPort) else: # For py4j 0.9 (used by Spark 1.6), it doesn't have way to set the dynamic port of the callback server, # hence we need the hack to call SparkPythonUtil to set it callbackPort = gateway._callback_server.server_socket.getsockname( )[1] gateway.jvm.SparkPythonUtil.setGatewayCallbackPort( JavaObject("GATEWAY_SERVER", gateway._gateway_client), callbackPort) cls._gateway = gateway cls._jvm = gateway.jvm cls._runtimeContext = cls._jvm.SparkRuntimeContextProvider.get( ) print "Java gateway initialized with gateway port ", gatewayPort
def __init__(self, tmpdir, log, quiet, append, branching_factor, skip_logging_configuration, optimizer_iterations): super(LocalBackend, self).__init__() spark_home = find_spark_home() hail_jar_path = os.environ.get('HAIL_JAR') if hail_jar_path is None: if pkg_resources.resource_exists(__name__, "hail-all-spark.jar"): hail_jar_path = pkg_resources.resource_filename(__name__, "hail-all-spark.jar") else: raise RuntimeError('local backend requires a packaged jar or HAIL_JAR to be set') port = launch_gateway( redirect_stdout=sys.stdout, redirect_stderr=sys.stderr, jarpath=f'{spark_home}/jars/py4j-0.10.9.jar', classpath=f'{spark_home}/jars/*:{hail_jar_path}', die_on_exit=True) self._gateway = JavaGateway( gateway_parameters=GatewayParameters(port=port, auto_convert=True)) self._jvm = self._gateway.jvm hail_package = getattr(self._jvm, 'is').hail self._hail_package = hail_package self._utils_package_object = scala_package_object(hail_package.utils) self._jbackend = hail_package.backend.local.LocalBackend.apply(tmpdir) self._jhc = hail_package.HailContext.apply( self._jbackend, log, True, append, branching_factor, skip_logging_configuration, optimizer_iterations) # This has to go after creating the SparkSession. Unclear why. # Maybe it does its own patch? install_exception_handler() from hail.context import version py_version = version() jar_version = self._jhc.version() if jar_version != py_version: raise RuntimeError(f"Hail version mismatch between JAR and Python library\n" f" JAR: {jar_version}\n" f" Python: {py_version}") self._fs = LocalFS() self._logger = None if not quiet: connect_logger(self._utils_package_object, 'localhost', 12888)
def start_server(self): server_start_instructions = ['java', '-jar'] server_args = [ '../LTLCheckForTraces.jar', str(self._port), str(self._python_port) ] self._server_process = subprocess.Popen(server_start_instructions + list(server_args)) self._gateway = JavaGateway( gateway_parameters=GatewayParameters(port=self._port), python_proxy_port=self._python_port) self._traces_checker = self._gateway.entry_point
def internal_work(assert_memory): gateway2 = InstrJavaGateway( gateway_parameters=GatewayParameters(port=DEFAULT_PORT + 5), callback_server_parameters=CallbackServerParameters( port=DEFAULT_PYTHON_PROXY_PORT + 5)) sleep() play_with_ping(gateway2) python_gc() sleep() gateway2.close(close_callback_server_connections=True, keep_callback_server=True) sleep() assert_memory() gateway2.shutdown() sleep()
def start_game(Character): for Chara in Character: # FFT GRU for i in range(30): gateway = JavaGateway(gateway_parameters=GatewayParameters(port=4242), callback_server_parameters=CallbackServerParameters()); manager = gateway.entry_point ai_name = 'FFTGRU' manager.registerAI(ai_name, SoundAgent(gateway,logger=logger, encoder='fft', path='trained_model', rnn=True)) print("Start game") game = manager.createGame(Chara, Chara, ai_name, "MctsAi65", GAME_NUM) manager.runGame(game) print("After game") sys.stdout.flush() close_gateway(gateway)
def init_jvm(max_heap=1024, jar_path="./libs"): """KOMORAN Jar를 포함한 JVM을 초기화한 후, 반환합니다. Args: max_heap (int): JVM 실행 시 Max Heap Size (기본값: ``1024``, 단위: ``MB``) jar_path (str): JVM 실행 시 포함할 Jar Path 지정 (기본값: ``"./libs"``) Returns: py4j.java_gateway.JavaGateway: 초기화된 JVM 객체 """ base_path = os.path.dirname(os.path.realpath(__file__)) jar_path = os.path.abspath(os.path.join(base_path, jar_path)) assert os.path.exists(jar_path) global jvm_gateway if jvm_gateway is not None: return libraries = [ '{0}{1}KOMORAN-4e7b5ef.jar', '{0}{1}KOMORANEntryPoint-0.1.0.jar', # '{0}{1}*' ] classpath = os.pathsep.join( [lib.format(jar_path, os.sep) for lib in libraries]) py4j_path = "{0}{1}py4j0.10.8.1.jar".format(jar_path, os.sep) port = launch_gateway( jarpath=py4j_path, classpath=classpath, javaopts=['-Dfile.encoding=UTF8', '-ea', '-Xmx{}m'.format(max_heap)], die_on_exit=True) logging.debug("initializing JVM... ") try: jvm_gateway = JavaGateway( gateway_parameters=GatewayParameters(port=port, auto_convert=True)) # # for debugging with Java-side # jvm_gateway = JavaGateway(gateway_parameters=GatewayParameters(port=25335, auto_convert=True)) except Exception as e: jvm_gateway = None logging.debug("fail") logging.debug("success") return jvm_gateway.jvm
def __init__(self, cachesize=10000): from py4j.java_gateway import JavaGateway, JavaObject, GatewayParameters # from py4j.java_gateway import java_import, get_field from sagas.conf.runtime import runtime host = "localhost" if not runtime.is_docker() else 'ruleprocs' port = 4333 callback_port = 4334 self.gateway = JavaGateway(python_proxy_port=callback_port, gateway_parameters=GatewayParameters( address=host, port=port, auto_field=True)) self.j = self.gateway.new_jvm_view() self.cache = LRUCache(maxsize=cachesize)
def testNoAutoField(self): self.gateway = JavaGateway(gateway_parameters=GatewayParameters( auto_field=False)) ex = self.gateway.getNewExample() self.assertTrue(isinstance(ex.field10, JavaMember)) self.assertTrue(isinstance(ex.field50, JavaMember)) self.assertEqual(10, get_field(ex, "field10")) # This field does not exist self.assertRaises(Exception, get_field, ex, "field50") # With auto field = True ex._auto_field = True sb = ex.field20 sb.append("Hello") self.assertEqual("Hello", sb.toString())
def __init__(self, host="localhost", port=22333, callback_port=22334): logger.info("connect to py4j-gateway %s %d"%(host, port)) # self.gateway = JavaGateway() # connect to the JVM self.gateway = JavaGateway(python_proxy_port=callback_port, gateway_parameters=GatewayParameters(address=host, port=port)) self.delegator = self.gateway.entry_point.getDelegator() self.dispatcher=self.gateway.entry_point.getDispatcher() self.ctx= self.dispatcher.getDispatchContext() self.j = self.gateway.new_jvm_view() self.srv_rpc=None java_import(self.j, 'java.util.*') java_import(self.j, 'org.apache.ofbiz.base.util.*') java_import(self.j, 'com.sagas.generic.*') java_import(self.j, 'org.apache.ofbiz.entity.transaction.TransactionUtil')
def main(): """TODO: Docstring for main. :returns: TODO """ server_proc = subprocess.Popen(['java', '-jar', "./faceserver.jar"]) clients = 4 for port in range(25335, 25335 + clients): gateway = JavaGateway(gateway_parameters=GatewayParameters(port=port)) face_client = gateway.entry_point __import__('ipdb').set_trace() __import__('pprint').pprint(face_client) server_proc.kill()
def start(): assert (not __env) __env["proc"] = subprocess.Popen(["GINsim", "-py"], \ stdout=PIPE, stdin=PIPE, stderr=PIPE) port = int(__env["proc"].stdout.readline().strip()) # start the gateway and return the entry point (GINsim's ScriptLauncher) param = GatewayParameters(port=port, auto_convert=True, auto_field=True) __env["gw"] = JavaGateway(gateway_parameters=param) global japi japi.java = __env["gw"] japi.gs = __env["gw"].entry_point japi.lqm = japi.gs.LQM() for module in __registered: module._japi_start()
def start_gateway_server(gmql_jar, instances_file): port_n = check_instances(instances_file) # print("Using port {}".format(port_n)) java_home = os.environ.get("JAVA_HOME") if java_home is None: raise SystemError("The environment variable JAVA_HOME is not setted") java_path = os.path.join(java_home, "bin", "java") gmql_jar_fn = resource_filename( "gmql", os.path.join("resources", gmql_jar)) gmql_jar_fn = check_backend(gmql_jar_fn) command = [java_path, '-jar', gmql_jar_fn, str(port_n)] proc = sp.Popen(command) synchronize() gateway = JavaGateway(gateway_parameters=GatewayParameters( auto_convert=True, port=port_n)) return proc, gateway, port_n
def genius_bridge_is_running(port: int = DEFAULT_JAVA_PORT) -> bool: """ Checks whether a Genius Bridge is running. A genius bridge allows you to use `GeniusNegotiator` objects. Remarks: You can start a Genius Bridge in at least three ways: - execute the python function `init_genius_bridge()` in this module - run "negmas genius" on the terminal - execute `GeniusBridge.start()` """ s = socket.socket() s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: s.connect(("127.0.0.1", port)) s.close() # we know someone is listening. Now we check that it is us gateway = JavaGateway( gateway_parameters=GatewayParameters(port=port, auto_close=True), callback_server_parameters=CallbackServerParameters( port=0, daemonize=True, daemonize_connections=True), ) gateway.jvm.System.currentTimeMillis() return True except ConnectionRefusedError: # try: # s.shutdown(2) # except: # pass s.close() return False except IndexError: # try: # s.shutdown(2) # except: # pass s.close() return False except Py4JNetworkError: # try: # s.shutdown(2) # except: # pass s.close() return False
def testIpV6(self): self.p = start_ipv6_app_process() gateway = JavaGateway( gateway_parameters=GatewayParameters(address="::1"), callback_server_parameters=CallbackServerParameters(address="::1")) try: timeMillis = gateway.jvm.System.currentTimeMillis() self.assertTrue(timeMillis > 0) operator = WaitOperator(0.1) opExample = gateway.jvm.py4j.examples.OperatorExample() a_list = opExample.randomBinaryOperator(operator) self.assertEqual(a_list[0] + a_list[1], a_list[2]) finally: gateway.shutdown() self.p.join()
def start_api_server(): port = launch_gateway(classpath="/home/nithin/Desktop/Georgia Tech/Spring 2019/Adaptive Control and Reinforcement Learning/ACRL/Tetris/src", die_on_exit=True) global gateway gateway = JavaGateway(gateway_parameters=GatewayParameters(port=port)) player_tetris = gateway.jvm.PlayerSkeletonCommunication().getFeatures() weight = gateway.jvm.java.util.ArrayList() weight.append(1.0) weight.append(2.0) weight.append(3.0) weight.append(4.0) weight.append(5.0) weight.append(6.0) weight.append(7.0) weight.append(8.0) return player_tetris, weight
def worker(i): gateway = JavaGateway( gateway_parameters=GatewayParameters(port=(6000 + i)), callback_server_parameters=CallbackServerParameters(port=0)) python_port = gateway.get_callback_server().get_listening_port() gateway.java_gateway_server.resetCallbackClient( gateway.java_gateway_server.getCallbackClient().getAddress(), python_port) manager = gateway.entry_point Bruce = BruceL33p(gateway) main_process(manager, gateway, Bruce, i) Bruce.WriteResults(i + 1) return
def __init__(self, languageCode): """ Parameters ---------- languageCode: code like "de-DE" or "en" """ try: self.gateway = JavaGateway(gateway_parameters=GatewayParameters( auto_convert=True)) self.languageCode = languageCode self.language = self.gateway.jvm.org.languagetool.Languages.getLanguageForShortCode( languageCode) self.tagger = self.language.getTagger() except Py4JNetworkError as e: raise RuntimeError( "Could not connect to JVM. Is ./gradlew pythonGateway running?" ) from e
def lancer_gateway(): global gateway_connection, gateway, couleurs # Crée le lien entre le backend et le frontend gateway_connection = JavaGateway(gateway_parameters=GatewayParameters( port=10001)) gateway = gateway_connection.entry_point try: # Teste s'il y a une erreur avec la connexion gateway.getColors() except Exception: print("Erreur lors de la connexion au back end.\nEst-il bien lancé ?") exit(0) for c in gateway.getColors(): col = (c[0], c[1], c[2]) couleurs.append(col)
def _start_gateway(self): # auto select callback server port and reset it in java env self.gateway = JavaGateway( gateway_parameters=GatewayParameters( port=self.port, enable_memory_management=True, # read_timeout=5 ), callback_server_parameters=CallbackServerParameters( port=self.port + 1 # propagate_java_exceptions=True ), ) self.python_port = self.gateway.get_callback_server().get_listening_port() # print("python_port:{}".format(self.python_port)) self.gateway.java_gateway_server.resetCallbackClient( self.gateway.java_gateway_server.getCallbackClient().getAddress(), self.python_port) self.manager = self.gateway.entry_point # create pipe between gym_env_api and python_ai for java env server, client = Pipe() self.pipe = server self.client = client # change the no frameskip flag if self.display: self.p1 = GymAIDisplay(self.gateway, self.client, self.frameskip) else: self.p1 = GymAI(self.gateway, self.client, self.frameskip,self.use_sim) self.manager.registerAI(self.p1.__class__.__name__, self.p1) if isinstance(self.p2, str): # p2 is a java class name self.game_to_start = self.manager.createGame( "ZEN", "ZEN", self.p1.__class__.__name__, self.p2, self.freq_restart_java) else: # p2 is a python class self.p2 = self.p2(self.gateway) self.manager.registerAI(self.p2.__class__.__name__, self.p2) self.game_to_start = self.manager.createGame( "ZEN", "ZEN", self.p1.__class__.__name__, self.p2.__class__.__name__, self.freq_restart_java) self.game = Thread(target=game_thread, name="game_thread", args=(self, )) self.game.start() self.game_started = True self.round_num = 0
def __init__(self, tmpdir, log, quiet, append, branching_factor, skip_logging_configuration, optimizer_iterations): SPARK_HOME = os.environ['SPARK_HOME'] HAIL_HOME = os.environ['HAIL_HOME'] port = launch_gateway( redirect_stdout=sys.stdout, redirect_stderr=sys.stderr, jarpath=f'{SPARK_HOME}/jars/py4j-0.10.7.jar', classpath= f'{SPARK_HOME}/jars/*:{HAIL_HOME}/hail/build/libs/hail-all-spark.jar', die_on_exit=True) self._gateway = JavaGateway( gateway_parameters=GatewayParameters(port=port, auto_convert=True)) self._jvm = self._gateway.jvm hail_package = getattr(self._jvm, 'is').hail self._hail_package = hail_package self._utils_package_object = scala_package_object(hail_package.utils) self._jbackend = hail_package.backend.local.LocalBackend.apply(tmpdir) self._jhc = hail_package.HailContext.apply(self._jbackend, log, True, append, branching_factor, skip_logging_configuration, optimizer_iterations) # This has to go after creating the SparkSession. Unclear why. # Maybe it does its own patch? install_exception_handler() from hail.context import version py_version = version() jar_version = self._jhc.version() if jar_version != py_version: raise RuntimeError( f"Hail version mismatch between JAR and Python library\n" f" JAR: {jar_version}\n" f" Python: {py_version}") self._fs = LocalFS() self._logger = None if not quiet: connect_logger(self._utils_package_object, 'localhost', 12888)
def _start_gateway(self, p2=Machete): # auto select callback server port and reset it in java env self.gateway = JavaGateway( gateway_parameters=GatewayParameters(port=self.port), callback_server_parameters=CallbackServerParameters(port=0), ) python_port = self.gateway.get_callback_server().get_listening_port() self.gateway.java_gateway_server.resetCallbackClient( self.gateway.java_gateway_server.getCallbackClient().getAddress(), python_port, ) self.manager = self.gateway.entry_point # create pipe between gym_env_api and python_ai for java env server, client = Pipe() self.pipe = server self.p1 = GymAI(self.gateway, client, False) self.manager.registerAI(self.p1.__class__.__name__, self.p1) if isinstance(p2, str): # p2 is a java class name self.p2 = p2 self.game_to_start = self.manager.createGame( "ZEN", "ZEN", self.p1.__class__.__name__, self.p2, self.freq_restart_java, ) else: # p2 is a python class self.p2 = p2(self.gateway) self.manager.registerAI(self.p2.__class__.__name__, self.p2) self.game_to_start = self.manager.createGame( "ZEN", "ZEN", self.p1.__class__.__name__, self.p2.__class__.__name__, self.freq_restart_java, ) self.game = Thread(target=game_thread, name="game_thread", args=(self,)) self.game.start() self.game_started = True self.round_num = 0
def testException(self): try: testSocket = get_socket() testSocket.sendall("!yo\n".encode("utf-8")) testSocket.sendall("!yro0\n".encode("utf-8")) testSocket.sendall("!yo\n".encode("utf-8")) testSocket.sendall(b"!x\n") testSocket.close() sleep() self.gateway = JavaGateway(gateway_parameters=GatewayParameters( auto_field=True)) ex = self.gateway.getNewExample() self.assertRaises(Py4JError, lambda: ex.method3(1, True)) self.gateway.shutdown() except Exception: self.fail("Problem occurred")