def init_cb_service(spark: SparkSession, enable_dynamic_port: bool):
jvm = spark.sparkContext._gateway
# Set port to 0 to enable dynamic port
# Re-use the auth-token from the main java/spark process
if enable_dynamic_port:
params = CallbackServerParameters(
daemonize=True,
daemonize_connections=True,
# https://www.py4j.org/advanced_topics.html#using-py4j-without-pre-determined-ports-dynamic-port-number
port=0,
auth_token=jvm.gateway_parameters.auth_token,
)
else:
params = CallbackServerParameters(
daemonize=True,
daemonize_connections=True,
auth_token=jvm.gateway_parameters.auth_token,
)
jvm.start_callback_server(callback_server_parameters=params)
if enable_dynamic_port:
python_port = jvm.get_callback_server().get_listening_port()
jvm.java_gateway_server.resetCallbackClient(
jvm.java_gateway_server.getCallbackClient().getAddress(),
python_port,
)
else:
jvm.start_callback_server(callback_server_parameters=params)
logger.info("Spark callback server started")
cb = CallbackService(spark)
cb.register()
def setUp(self):
key_file = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"selfsigned.pem")
client_ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
client_ssl_context.verify_mode = ssl.CERT_REQUIRED
client_ssl_context.check_hostname = True
client_ssl_context.load_verify_locations(cafile=key_file)
server_ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
server_ssl_context.load_cert_chain(key_file, password='******')
callback_server_parameters = CallbackServerParameters(
ssl_context=server_ssl_context)
# address must match cert, because we're checking hostnames
gateway_parameters = GatewayParameters(
address='localhost',
ssl_context=client_ssl_context)
self.p = start_example_tls_process()
self.gateway = JavaGateway(
gateway_parameters=gateway_parameters,
callback_server_parameters=callback_server_parameters)
# It seems SecureServerSocket may need a little more time to
# initialize on some platforms/slow machines.
sleep(0.500)
def testDoubleCallbackServer(self):
try:
self.gateway2 = JavaGateway(
callback_server_parameters=CallbackServerParameters())
self.fail()
except Exception:
self.assertTrue(True)
def setUp(self):
# logger = logging.getLogger("py4j")
# logger.setLevel(logging.DEBUG)
# logger.addHandler(logging.StreamHandler())
self.p = start_example_app_process()
self.gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
def _setup_py4j_client_connection(self):
gateway_params = GatewayParameters(port=self._java_port,
auto_field=True,
auto_close=True,
eager_load=True)
callback_server_params = CallbackServerParameters(
port=0,
daemonize=True,
daemonize_connections=True,
eager_load=True)
self._gateway = JavaGateway(
gateway_parameters=gateway_params,
callback_server_parameters=callback_server_params,
python_server_entry_point=self)
self._component_via_py4j = self._gateway.entry_point.getComponent()
if not self._component_via_py4j:
raise MLCompException("None reference of py4j java object!")
if self._verbose:
self._logger.debug(
self._prefix_msg +
"Py4J component referenced successfully! comp_via_py4j: {}".
format(self._component_via_py4j))
self._component_via_py4j.setEnvAttributes(self.get_wid(),
self._verbose)
def _start_gateway(port=0) -> JavaGateway:
# launch Java side with dynamic port and get back the port on which the
# server was bound to.
port = launch_gateway(
port=port,
classpath=Context.find_resource_path('net-0.8.22.jar'),
javaopts=[
"--add-modules", "java.se", "--add-exports",
"java.base/jdk.internal.ref=ALL-UNNAMED", "--add-opens",
"java.base/java.lang=ALL-UNNAMED", "--add-opens",
"java.base/java.nio=ALL-UNNAMED", "--add-opens",
"java.base/sun.nio.ch=ALL-UNNAMED", "--add-opens",
"java.management/sun.management=ALL-UNNAMED", "--add-opens",
"jdk.management/com.sun.management.internal=ALL-UNNAMED"
],
die_on_exit=True)
# connect python side to Java side with Java dynamic port and start python
# callback server with a dynamic port
gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=port, auto_convert=True),
callback_server_parameters=CallbackServerParameters(port=0))
# retrieve the port on which the python callback server was bound to.
python_port = gateway.get_callback_server().get_listening_port()
# tell the Java side to connect to the python callback server with the new
# python port. Note that we use the java_gateway_server attribute that
# retrieves the GatewayServer instance.
gateway.java_gateway_server.resetCallbackClient(
gateway.java_gateway_server.getCallbackClient().getAddress(),
python_port)
return gateway
def _validate(self, _):
# here is where we can get java and python ports and change the
# defaults for connecting
try:
self._bridge = Py4jServiceBridge(
service_listener=self,
gateway_parameters=GatewayParameters(port=self._javaport),
callback_server_parameters=CallbackServerParameters(
port=self._pythonport
),
)
self._bridge.connect()
except Exception as e:
self._bridge = None
raise e
# Once bridge is connected, instantiate container using bridge id
container_props = self._prepare_container_props(
self._supported_intents, None
)
if self._default_service_timeout:
container_props[
ECF_PY4J_DEFAULT_SERVICE_TIMEOUT
] = self._default_service_timeout
self._container = self._ipopo.instantiate(
self._config_name, self._bridge.get_id(), container_props
)
def _make_a_game(self, p1, p2, n_game, **kwargs):
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()
# logger.info(str(self.gateway.java_gateway_server.getCallbackClient().getAddress(), python_port))
self.gateway.java_gateway_server.resetCallbackClient(
self.gateway.java_gateway_server.getCallbackClient().getAddress(), python_port)
self.manager = self.gateway.entry_point
connect_monitor = kwargs.get('ai_monitor', lambda a, b, c: None)
def run_a_game():
# n = 0
# while n_game is None or n < n_game:
# p1_character, p1_name, p1_obj = self._create_player(self.gateway, self.manager, p1)
# connect_monitor(self.id, 1, p1_obj)
# p2_character, p2_name, p2_obj = self._create_player(self.gateway, self.manager, p2)
# connect_monitor(self.id, 2, p2_obj)
# game = self.manager.createGame(p1_character, p2_character, p1_name, p2_name, 1)
# self.manager.runGame(game)
# n += 1
p1_character, p1_name, p1_obj = self._create_player(self.gateway, self.manager, p1)
connect_monitor(self.id, 1, p1_obj)
p2_character, p2_name, p2_obj = self._create_player(self.gateway, self.manager, p2)
connect_monitor(self.id, 2, p2_obj)
game = self.manager.createGame(p1_character, p2_character, p1_name, p2_name, n_game)
print("GAME", p1_character, p2_character, p1_name, p2_name, n_game)
self.manager.runGame(game)
self.gateway.shutdown_callback_server(raise_exception=False)
self.gateway.shutdown(raise_exception=False)
sys.stdout.flush()
return run_a_game
def __init__(self, sourceFile, targetFile):
self.SWindow = []
self.TWindow = []
self.TPredictWindow = []
self.SDataBuffer = [] #Queue
self.TDataBuffer = [] #Queue
self.SInitialDataBuffer = []
self.TInitialDataBuffer = []
self.changeDetector = ChangeDetection(Properties.GAMMA,
Properties.SENSITIVITY,
Properties.MAX_WINDOW_SIZE)
self.ensemble = Ensemble(Properties.ENSEMBLE_SIZE)
classNameList = []
self.source = Stream(sourceFile, classNameList,
Properties.INITIAL_DATA_SIZE)
self.target = Stream(targetFile, classNameList,
Properties.INITIAL_DATA_SIZE)
Properties.MAXVAR = self.source.MAXVAR
self.gateway = JavaGateway(
start_callback_server=True,
gateway_parameters=GatewayParameters(port=Properties.PY4JPORT),
callback_server_parameters=CallbackServerParameters(
port=Properties.PY4JPORT + 1))
self.app = self.gateway.entry_point
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'])
callback_port = int(os.environ['PYFLINK_CALLBACK_PORT'])
gateway_param = GatewayParameters(port=gateway_port,
auto_convert=True)
_gateway = JavaGateway(
gateway_parameters=gateway_param,
callback_server_parameters=CallbackServerParameters(
port=callback_port,
daemonize=True,
daemonize_connections=True))
else:
_gateway = launch_gateway()
# import the flink view
import_flink_view(_gateway)
install_exception_handler()
_gateway.entry_point.put("PythonFunctionFactory",
PythonFunctionFactory())
_gateway.entry_point.put("Watchdog", Watchdog())
return _gateway
def testGC(self):
with gateway_example_app_process("nomem"):
# This will only work with some JVM.
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
sleep()
example = gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
self.assertEqual("This is Hello;\n10MyMy!\n;",
example.callHello2(impl))
self.assertEqual(2, len(gateway.gateway_property.pool))
# Make sure that finalizers do not block
impl2 = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl2))
self.assertEqual(3, len(gateway.gateway_property.pool))
gateway.jvm.java.lang.System.gc()
# Leave time for sotimeout
sleep(3)
# Make sure the three objects have not been removed from the pool
# because the Java side should not send gc request.
self.assertEqual(len(gateway.gateway_property.pool), 3)
gateway.shutdown()
def start(self, args):
# print('For the directory of the script being run:\n', pathlib.Path(__file__).parent.absolute())
# print('For the current working directory:\n', pathlib.Path().absolute())
# print('Arguments length = ', len(args))
# Spring Libs
# gw_args = ['java', '-jar', str(pathlib.Path(__file__).parent.absolute())+'/lib/spring-cloud-stream-gateway-0.1.7.jar', '-noverify', '-XX:TieredStopAtLevel=1', '-Dspring.jmx.enabled=false']
# KAFKA Consumer Libs
gw_args = [
'java', '-jar',
str(pathlib.Path(__file__).parent.absolute()) +
'/lib/spring-cloud-stream-gateway-0.1.8.jar'
]
# print(gw_args)
gw_args.extend(args)
# print(gw_args)
# for arg in args:
# print('Arg: ', arg)
# for output_line in run_command('java -jar ../resources/lib/spring-cloud-stream-gateway-0.1.7.jar --spring.config.location=file:../resources/application.yml'):
for output_line in self.run_command(gw_args):
print(output_line)
if output_line == b'serverStarted\n':
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
# listener = StreamGateway(gateway)
gateway.entry_point.registerListener(self)
# self.execfunc.postConstruct()
break
def __get_random_port_for_callback_server(self) -> None:
# See: https://github.com/bartdag/py4j/issues/147
self._gateway.start_callback_server(
CallbackServerParameters(port=0, daemonize=True, daemonize_connections=True))
jgws = JavaObject("GATEWAY_SERVER", self._gateway._gateway_client)
jgws.resetCallbackClient(jgws.getCallbackClient().getAddress(),
self._gateway.get_callback_server().get_listening_port())
def main():
p = OptionParser()
p.add_option('-j',
'--jvm_port',
help='the port for jvm side',
dest='jvm_port',
type=int,
default=None)
p.add_option('-p',
'--py_port',
help='the port for python side',
dest='py_port',
type=int,
default=None)
(z, args) = p.parse_args()
app = PyMain()
global gateway
gateway = JavaGateway(gateway_parameters=GatewayParameters(
port=z.jvm_port, auto_field=True, auto_convert=True),
callback_server_parameters=CallbackServerParameters(
port=z.py_port,
daemonize=True,
daemonize_connections=False,
propagate_java_exceptions=True),
python_server_entry_point=app)
print('Started Listening On {}'.format(
gateway.get_callback_server().get_listening_port()))
sys.stdout.flush()
while app.check():
time.sleep(1.0)
print('Exit')
def test_all_regular_signals_auto_start(self):
listener = MockListener(self)
with gateway_example_app_process(None):
server_started.connect(listener.started)
gateway = JavaGateway(
gateway_parameters=GatewayParameters(),
callback_server_parameters=CallbackServerParameters())
server_stopped.connect(listener.stopped,
sender=gateway.get_callback_server())
server_connection_started.connect(
listener.connection_started,
sender=gateway.get_callback_server())
server_connection_stopped.connect(
listener.connection_stopped,
sender=gateway.get_callback_server())
pre_server_shutdown.connect(listener.pre_shutdown,
sender=gateway.get_callback_server())
post_server_shutdown.connect(listener.post_shutdown,
sender=gateway.get_callback_server())
example = gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
gateway.shutdown()
self.assertEqual(1, listener.received["started"])
self.assertEqual(1, listener.received["stopped"])
self.assertEqual(1, listener.received["pre_shutdown"])
self.assertEqual(1, listener.received["post_shutdown"])
self.assertEqual(1, listener.received["connection_started"])
self.assertEqual(1, listener.received["connection_stopped"])
def _start_gateway(port=0) -> JavaGateway:
# launch Java side with dynamic port and get back the port on which the
# server was bound to.
hearthstone_jar_path = Context.find_resource_path(
'hearthstone-0.8.67.jar')
net_jar_path = Context.find_resource_path('net-0.8.67-all.jar')
port = launch_gateway(port=port,
classpath=os.pathsep.join(
(hearthstone_jar_path, net_jar_path)),
die_on_exit=True)
# connect python side to Java side with Java dynamic port and start python
# callback server with a dynamic port
gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=port, auto_convert=True),
callback_server_parameters=CallbackServerParameters(port=0))
# retrieve the port on which the python callback server was bound to.
python_port = gateway.get_callback_server().get_listening_port()
# tell the Java side to connect to the python callback server with the new
# python port. Note that we use the java_gateway_server attribute that
# retrieves the GatewayServer instance.
gateway.java_gateway_server.resetCallbackClient(
gateway.java_gateway_server.getCallbackClient().getAddress(),
python_port)
return gateway
def testBadRetryFromJava(self):
"""Should not retry from Java to Python.
Similar use case as testBadRetry, but from Java: Java calls a long
Python operation.
If there is a bug, Java will call Python, then read will fail, then it
will call Python again.
If there is no bug, Java will call Python, read will fail, then Java
will raise an Exception that will be received as a Py4JError on the
Python side.
"""
self.p = start_short_timeout_app_process()
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
try:
operator = WaitOperator(0.5)
opExample = gateway.jvm.py4j.examples.OperatorExample()
opExample.randomBinaryOperator(operator)
self.fail("Should never retry once the first command went through."
" number of calls made: {0}".format(operator.callCount))
except Py4JJavaError:
self.assertTrue(True)
finally:
gateway.shutdown()
self.p.join()
def testCallbackServer(self):
# A close is required to stop the thread.
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
gateway.close()
self.assertTrue(True)
sleep(2)
def __init__(self, n=3):
"Set up initial board configuration."
gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=4242),
callback_server_parameters=CallbackServerParameters())
manager = gateway.entry_point
def _start_gateway() -> JavaGateway:
# launch Java side with dynamic port and get back the port on which the
# server was bound to.
port = launch_gateway(port=0,
classpath=Context._find_jar_path('net-1.3.0-all.jar'),
javaopts=['-javaagent:' + Context._find_jar_path('quasar-core-0.7.9-jdk8.jar') + '=mb',
'-Xmx2048m'],
die_on_exit=True)
# connect python side to Java side with Java dynamic port and start python
# callback server with a dynamic port
gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=port, auto_convert=True),
callback_server_parameters=CallbackServerParameters(port=0))
# retrieve the port on which the python callback server was bound to.
python_port = gateway.get_callback_server().get_listening_port()
# tell the Java side to connect to the python callback server with the new
# python port. Note that we use the java_gateway_server attribute that
# retrieves the GatewayServer instance.
gateway.java_gateway_server.resetCallbackClient(
gateway.java_gateway_server.getCallbackClient().getAddress(),
python_port)
return gateway
def get_gateway():
# type: () -> JavaGateway
global _gateway
global _lock
with _lock:
if _gateway is None:
# Set the level to WARN to mute the noisy INFO level logs
logger.level = WARN
# 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,
callback_server_parameters=CallbackServerParameters(
port=0, daemonize=True, daemonize_connections=True))
else:
_gateway = launch_gateway()
callback_server = _gateway.get_callback_server()
callback_server_listening_address = callback_server.get_listening_address()
callback_server_listening_port = callback_server.get_listening_port()
_gateway.jvm.org.apache.flink.client.python.PythonEnvUtils.resetCallbackClient(
_gateway.java_gateway_server,
callback_server_listening_address,
callback_server_listening_port)
# import the flink view
import_flink_view(_gateway)
install_exception_handler()
install_py4j_hooks()
_gateway.entry_point.put("PythonFunctionFactory", PythonFunctionFactory())
_gateway.entry_point.put("Watchdog", Watchdog())
return _gateway
def _initialize_gateway(gateway_address):
(host, port) = gateway_address
callback_params = CallbackServerParameters(address=host, port=0)
gateway = JavaGateway(GatewayClient(address=host, port=port),
start_callback_server=True,
auto_convert=True,
callback_server_parameters=callback_params)
try:
java_import(gateway.jvm, "org.apache.spark.SparkEnv")
java_import(gateway.jvm, "org.apache.spark.SparkConf")
java_import(gateway.jvm, "org.apache.spark.api.java.*")
java_import(gateway.jvm, "org.apache.spark.api.python.*")
java_import(gateway.jvm, "org.apache.spark.mllib.api.python.*")
java_import(gateway.jvm, "org.apache.spark.sql.*")
java_import(gateway.jvm, "org.apache.spark.sql.hive.*")
java_import(gateway.jvm, "scala.Tuple2")
java_import(gateway.jvm, "scala.collection.immutable.List")
except Py4JError as e:
log_error('Error while initializing java gateway: {}'.format(e))
gateway.close()
return None
log_debug('Java Gateway initialized {}'.format(gateway))
return gateway
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 = GymAIDisplay(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 main(iterations):
small_iterations = iterations / 10 if iterations > 10 else iterations
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
currentTimeMillis = gateway.jvm.java.lang.System.currentTimeMillis
sb = gateway.jvm.java.lang.StringBuilder()
append = sb.append
sb2 = gateway.jvm.java.lang.StringBuilder()
def reflection():
sb2.append(2)
sb2.append("hello")
def constructorAndMemoryManagement():
sb = gateway.jvm.java.lang.StringBuilder("Hello World")
sb.append("testing")
def javaCollection():
al = gateway.jvm.java.util.ArrayList()
al.append("test")
al.append(1)
al.append(True)
len(al)
result = []
for elem in al:
result.append(elem)
return result
def callBack():
al = gateway.jvm.java.util.ArrayList()
cp10 = ComparablePython(10)
cp1 = ComparablePython(1)
cp5 = ComparablePython(5)
cp7 = ComparablePython(7)
al.append(cp10)
al.append(cp1)
al.append(cp5)
al.append(cp7)
gateway.jvm.java.util.Collections.sort(al)
def longParamCall():
longParam = "s" * 1024 * 1024 * 10
sb = gateway.jvm.java.lang.StringBuilder()
sb.append(longParam)
sb.toString()
benchmark("callStaticMethodNoParam",
partial(callStaticMethodNoParam, iterations, currentTimeMillis))
benchmark("callInstanceMethodWithShortParam",
partial(callInstanceMethodWithShortParam, iterations, append))
benchmark("callWithReflection", partial(callFunc, iterations, reflection))
benchmark("constructorAndMemoryManagement",
partial(callFunc, iterations, constructorAndMemoryManagement))
benchmark("longParamAndMemoryManagement",
partial(callFunc, ITERATIONS_FOR_LENGTHY_METHOD, longParamCall))
benchmark("javaCollection",
partial(callFunc, small_iterations, javaCollection))
benchmark("callBack", partial(callFunc, small_iterations, callBack))
gateway.shutdown()
def __init__(self):
super(ImplementPy4J, self).__init__()
self.gateway = JavaGateway(
gateway_parameters=GatewayParameters(auto_field=True),
callback_server_parameters=CallbackServerParameters())
self.ep = self.gateway.entry_point
listener = self.ep.getListener()
listener.registerListener(self)
def setup(self, config):
self.risk_threshold = self.config["tuning_config"]["risk_threshold"]
self.max_concurrent_trials = self.config["tuning_config"][
"max_concurrent_trials"]
self.payoff_empirical_min = self.config["tuning_config"][
"obj_fnc_params"]["payoff_empirical_min"]
self.payoff_empirical_max = self.config["tuning_config"][
"obj_fnc_params"]["payoff_empirical_max"]
self.min_eval_eps = self.config["tuning_config"]["eval_eps_min"]
self.max_eval_eps = self.config["tuning_config"]["eval_eps_max"]
self.lock = threading.Lock()
self.train_results = queue.Queue()
self.eval_results = queue.Queue()
self.java_gateway = None
self.my_id = self.trial_id
self.start_time = time.time()
self.am_stopped = False
self.cur_max_score = self.payoff_empirical_min
self.cur_max_train_score = self.payoff_empirical_min
default_gateway = JavaGateway()
while self.java_gateway is None:
for i in range(self.max_concurrent_trials):
try:
self.my_port = 25334 + 2 * i
java_port = self.my_port - 1
# if addJavaPort fails, it means it is being used by some other trial running
# in a different process
if not default_gateway.addJavaPort(java_port):
if i == self.max_concurrent_trials - 1:
time.sleep(0.5)
continue
gateway_params = GatewayParameters(
port=java_port, enable_memory_management=False)
callback_params = CallbackServerParameters(
port=self.my_port)
self.java_gateway = JavaGateway(
gateway_parameters=gateway_params,
callback_server_parameters=callback_params)
break
except:
default_gateway.removeJavaPort(self.my_port - 1)
continue
default_gateway.close(keep_callback_server=True,
close_callback_server_connections=False)
encoded_trial_params = TuningParser.encode_trial_params(self.config)
self.results_receiver = _TrialResultsReceiver(self)
self.java_gateway.entry_point.runTrial(self.trial_id,
encoded_trial_params,
self.results_receiver)
self.additional_setup()
def _reset(self):
_message_with_frame('Environment reconnect...')
self._finalize()
self._simulator.connect()
self._gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=self._port),
callback_server_parameters=CallbackServerParameters())
self._manager = self._gateway.entry_point
_message_with_frame('Environment reconnect... done')
def init_genius_bridge(path: str = None,
port: int = 0,
force: bool = False) -> bool:
"""Initializes a genius connection
Args:
path: The path to a JAR file that runs negloader
port: port number to use
force: Force trial even if an existing bridge is initialized
Returns:
True if successful
"""
global common_gateway
global common_port
global java_process
global python_port
port = port if port > 0 else DEFAULT_JAVA_PORT
if genius_bridge_is_running(port):
return True
if not force and common_gateway is not None and common_port == port:
print("Java already initialized")
return True
path = NEGMAS_CONFIG.get(CONFIG_KEY_GENIUS_BRIDGE_JAR, None)
if path is None:
print(
"Cannot find the path to genius bridge jar. Download the jar somewhere in your machine and add its path"
'to ~/negmas/config.json under the key "genius_bridge_jar".\n\nFor example, if you downloaded the jar'
" to /path/to/your/jar then edit ~/negmas/config.json to read something like\n\n"
'{\n\t"genius_bridge_jar": "/path/to/your/jar",\n\t.... rest of the config\n}\n\n'
"You can find the jar at http://www.yasserm.com/scml/genius-8.0.4-bridge.jar"
)
return False
path = pathlib.Path(path).expanduser().absolute()
try:
subprocess.Popen( # ['java', '-jar', path, '--die-on-exit', f'{port}']
f"java -jar {path} --die-on-exit {port}",
shell=True)
except (OSError, TimeoutError, RuntimeError, ValueError):
return False
time.sleep(0.5)
gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=port),
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)
common_gateway = gateway
common_port = port
return True
def internal_work():
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.shutdown()
def __init__(self, user, pswd):
try:
self.gateway = JavaGateway(callback_server_parameters=CallbackServerParameters())
self.listener = PythonListener(self.gateway)
self.gateway.entry_point.registerListener(self.listener)
except:
print("JForexGateway4py (java) is not running.....")
os._exit(1)
time.sleep(1)
self.start(user, pswd)
