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")
