def start_clientserver_example_app_process(start_java_client=False,
start_short_timeout=False,
start_gc_test=False,
auth_token=None):
args = ()
gw_params = GatewayParameters()
if auth_token:
args = ("--auth-token", auth_token)
gw_params = GatewayParameters(auth_token=auth_token)
# XXX DO NOT FORGET TO KILL THE PROCESS IF THE TEST DOES NOT SUCCEED
if start_short_timeout:
p = Process(target=start_short_timeout_clientserver_example_server,
args=args)
elif start_java_client:
p = Process(target=start_java_clientserver_example_server, args=args)
elif start_gc_test:
p = Process(target=start_java_clientserver_gc_example_server,
args=args)
else:
p = Process(target=start_clientserver_example_server, args=args)
p.start()
sleep()
check_connection(gateway_parameters=gw_params)
return p
def __gateway(cls, classpath: str) -> JVMView:
from py4j.java_gateway import launch_gateway # ISSUE: ambient
port = launch_gateway(die_on_exit=True, classpath=classpath)
gw = JavaGateway(gateway_parameters=GatewayParameters(port=port))
jvm = gw.jvm
jvm = JavaGateway(gateway_parameters=GatewayParameters(port=port)).jvm
return jvm
def start_java_multi_client_server_app_process():
# XXX DO NOT FORGET TO KILL THE PROCESS IF THE TEST DOES NOT SUCCEED
p = Process(target=start_java_multi_client_server_app)
p.start()
sleep()
# test both gateways...
check_connection(gateway_parameters=GatewayParameters(port=DEFAULT_PORT))
check_connection(gateway_parameters=GatewayParameters(port=DEFAULT_PORT +
2))
return p
def __init__(
self, server_starter:
'nl4py.NetLogoControllerServerStarter.NetLogoControllerServerStarter'):
self.server_starter = server_starter
self.java_server = self.server_starter.jg.jvm.nl4py.server.NetLogoControllerServer(
)
self.server_gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_convert=True, port=server_starter.server_port))
gs = self.java_server.newGateway()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_convert=True, port=gs.getPort(), auto_close=True))
self.app = self.gateway.jvm.nl4py.server.NetLogoAppController(gs)
def testGatewayAuth(self):
self.gateway = JavaGateway.launch_gateway(enable_auth=True)
# Make sure the default client can connect to the server.
klass = self.gateway.jvm.java.lang.String
help_page = self.gateway.help(klass, short_name=True, display=False)
self.assertGreater(len(help_page), 1)
# Replace the client with one that does not authenticate.
# Make sure it fails.
bad_client = GatewayClient(gateway_parameters=GatewayParameters(
address=self.gateway.gateway_parameters.address,
port=self.gateway.gateway_parameters.port))
self.gateway.set_gateway_client(bad_client)
try:
self.gateway.help(klass, short_name=True, display=False)
self.fail("Expected failure to communicate with gateway server.")
except Exception:
# Expected
pass
finally:
# Restore a good client. This allows the gateway to be shut down.
good_client = GatewayClient(
gateway_parameters=self.gateway.gateway_parameters)
self.gateway.set_gateway_client(good_client)
def __init__(self, job_args):
self.use_api = job_args.get('use_api', False)
#setup the java gateway binding
self._gateway = JavaGateway(gateway_parameters=GatewayParameters(
port=job_args['java_gateway_port']))
repos = ["opensha", "nshm-nz-opensha"]
self._repoheads = get_repo_heads(PurePath(job_args['root_folder']),
repos)
self._output_folder = PurePath(job_args.get('working_path'))
if self.use_api:
headers = {"x-api-key": API_KEY}
self._ruptgen_api = RuptureGenerationTask(
API_URL,
S3_URL,
None,
with_schema_validation=True,
headers=headers)
self._general_api = GeneralTask(API_URL,
S3_URL,
None,
with_schema_validation=True,
headers=headers)
self._task_relation_api = TaskRelation(API_URL,
None,
with_schema_validation=True,
headers=headers)
self._toshi_api = ToshiApi(API_URL,
S3_URL,
None,
with_schema_validation=True,
headers=headers)
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 testGCCollectNoMemoryManagement(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
enable_memory_management=False))
gc.collect()
# Should have nothing in the finalizers
self.assertEqual(len(ThreadSafeFinalizer.finalizers), 0)
def internal():
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("Hello World")
sb2 = self.gateway.jvm.java.lang.StringBuffer()
sb2.append("Hello World")
finalizers_size_middle = len(ThreadSafeFinalizer.finalizers)
return finalizers_size_middle
finalizers_size_middle = internal()
gc.collect()
# Before collection: two objects created + two returned objects (append
# returns a stringbuffer reference for easy chaining).
self.assertEqual(finalizers_size_middle, 0)
# Assert after collection
self.assertEqual(len(ThreadSafeFinalizer.finalizers), 0)
self.gateway.shutdown()
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 __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 _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 _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 init(self):
"""
Sets up the Py4J Gateway. This is called automatically when other pygw classes are imported.
"""
if not self.is_initialized:
try:
if self.GATEWAY is None:
gateway_address = environ.get(PYGW_ADDRESS_ENV,
DEFAULT_ADDRESS)
gateway_port = environ.get(PYGW_PORT_ENV, DEFAULT_PORT)
self.GATEWAY = JavaGateway(
gateway_parameters=GatewayParameters(
auto_field=True,
address=gateway_address,
port=gateway_port))
try:
self.geowave_version = self.GATEWAY.jvm.org.locationtech.geowave.core.cli.VersionUtils\
.getVersion()
except TypeError as e:
raise GatewayConfiguration.PyGwGeoWaveNotFoundInGateway(
"GeoWave was not found in the configured gateway. Make sure GeoWave jars are available "
"on the classpath of the running gateway.") from e
self.is_initialized = True
except Py4JNetworkError as e:
raise GatewayConfiguration.PyGwJavaGatewayNotStartedError(
"The GeoWave Py4J Java Gateway must be running before you can use pygw."
) from e
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 get_java_gateway(port=0,
jarpath="",
classpath="",
javaopts=[],
die_on_exit=False,
redirect_stdout=None,
redirect_stderr=None,
daemonize_redirect=True,
java_path="java",
create_new_process_group=False,
enable_auth=False):
_ret = launch_gateway(port,
jarpath,
classpath,
javaopts,
die_on_exit,
redirect_stdout=redirect_stdout,
redirect_stderr=redirect_stderr,
daemonize_redirect=daemonize_redirect,
java_path=java_path,
create_new_process_group=create_new_process_group,
enable_auth=enable_auth,
return_proc=True)
if enable_auth:
_port, _auth_token, proc = _ret
else:
_port, proc, _auth_token = _ret + (None, )
gateway = JavaGateway(gateway_parameters=GatewayParameters(
port=_port, auth_token=_auth_token))
# NOTE 3: the Popen object is now available with gateway._proc
gateway._proc = proc
return gateway
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 _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 __init__(self, port_num=25333):
self.process = None
self.pid = None
self.port_number = str(port_num)
this_folder = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
root_folder = os.path.dirname(this_folder)
jar_file_name = os.path.join(
root_folder, 'javacnct', 'target',
'otm-py4j-1.0-SNAPSHOT-jar-with-dependencies.jar')
#First check if the file exists indeed:
if os.path.isfile(jar_file_name):
if platform.system() == "Windows":
self.openWindows(jar_file_name, self.port_number)
elif platform.system() in ["Linux", "Darwin"]:
self.openLinux(jar_file_name, self.port_number)
else:
raise Exception('Unknown platform')
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_convert=True, port=int(self.port_number)))
# self.gateway = JavaGateway(gateway_parameters=GatewayParameters(port=int(self.port_number)))
# self.gateway = JavaGateway()
else:
print("Jar file missing")
def init_jvm(jar_path="./libs", max_heap=1024):
global jvm_gateway
if jvm_gateway is not None:
return
libraries = [
'{0}{1}klay-python-wrapper-0.3.jar'
]
jar_path = './libs'
max_heap = 1024
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)
try:
jvm_gateway = JavaGateway(gateway_parameters=GatewayParameters(port=port, auto_convert=True))
except Exception as e:
jvm_gateway = None
logging.debug('fail')
logging.debug('success')
return jvm_gateway.jvm
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 __init__(self, setting_file_name: str,
utility_space: abstractUtilitySpace.AbstractUtilitySpace,
negotiation_rule: negotiationRule.NegotiationRule,
agent_id: int, agent_num: int, port: int):
"""
:param str setting_file_name: 効用ドメインファイルのパス
:param AbstractUtilitySpace utility_space: 効用空間の情報が取得できる
:param NegotiationRule negotiation_rule: 交渉の時間やタイプ，現在の正規化時間が取得できる
:param int agent_id: 自分のエージェントに割り振られたid
:param int agent_num: 交渉参加エージェントの数
:param int port: 通信を行うポート番号
"""
self.__utility_space = utility_space
self.__rule = negotiation_rule
self.__agent_id = agent_id
self.__issue_size_list = self.__utility_space.get_issue_size_list()
self.__opponent_bid = bid.Bid(len(self.__issue_size_list))
# JVMへ接続
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
port=port))
self.__setting_file_name = setting_file_name
# Geniusのagentのinit
self.__agent = self.gateway.entry_point
self.__agent_num = agent_num
self.__random_seed = 0
self.receive_start_negotiation()
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 init_py4j_stuff(self):
self.logger.info("Connecting to Java Gateway on port " +
str(self.port))
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_convert=True, port=self.port))
self.javaInterface = self.gateway.entry_point
self.logger.info("Connection to Java successful!")
def saveAndOpenSelection(df, dsName:str, objectClassIdx:int, selectionName:str, showObjects:bool=False, showTracks:bool=False, openSelection:bool=False, objectClassIdxDisplay:int=-1, interactiveObjectClassIdx:int=-1, port=25335, python_proxy_port:int=25334, address='127.0.0.1', gateway_parameters={}):
"""Stores a selection to bacmman using python gateway (py4j). Bacmman must be running with an active python gateway server.
Parameters
----------
df : pandas DataFrame
each line of the DataFrame is one element of the selection, defined by columns Indices & Position
dsName : str
bacmman dataset name to store the selection to.
objectClassIdx : int
index of the object class of the elements of the selection in the bacmman dataset
selectionName : str
name of the selection
showObjects : bool
whether contours of objects should be shown
showTracks : bool
whether track links of objects should be shown
openSelection : bool
whether the first kymograph of the selection should be open
objectClassIdxDisplay : int
if openSelection is true, object class idx of the opened kymograph
interactiveObjectClassIdx : int
if openSelection is true, interactive object class idx
python_proxy_port : int
python port of the java gateway
"""
gateway = JavaGateway(python_proxy_port=python_proxy_port, gateway_parameters=GatewayParameters(address=address, port=port, **gateway_parameters))
try:
idx = ListConverter().convert(df.Indices.tolist(), gateway._gateway_client)
pos = ListConverter().convert(df.Position.tolist(), gateway._gateway_client)
gateway.saveCurrentSelection(dsName, objectClassIdx, selectionName, idx, pos, showObjects, showTracks, openSelection, False, objectClassIdxDisplay, interactiveObjectClassIdx)
except Py4JNetworkError:
print("Could not connect, is BACMMAN started?")
def clusterJava(dataFrame):
def get_nodes(node, max_depth, depth):
leafs = []
children = node.getChildren()
if children and depth < max_depth:
for child in children:
childleafs = get_nodes(child, max_depth, depth+1)
leafs = leafs + childleafs
else:
leafs.append(node)
return leafs
dataFrame['cluster'] = None
from py4j.java_gateway import JavaGateway, GatewayParameters
gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_convert=True))
grouped = dataFrame.groupby('location')
locations = grouped.size().to_frame('size')
locations['x'] = grouped.first()['x']
locations['y'] = grouped.first()['y']
locations_flat = locations.reset_index().as_matrix()
# print('starting java clusterer')
# cluster_result_json = gateway.entry_point.run(locations_flat)
# print('java clusterer done')
# gateway.close()
# return cluster_result_json
resp = requests.post(os.environ.get('CLUSTERER_URL'), None, json.dumps(locations_flat.tolist()))
return resp.text
def __init__(self):
"""Starts a new instance of SystemDSContext, in which the connection to a JVM systemds instance is handled
Any new instance of this SystemDS Context, would start a separate new JVM.
Standard out and standard error form the JVM is also handled in this class, filling up Queues,
that can be read from to get the printed statements from the JVM.
"""
command = self.__build_startup_command()
# TODO add an argument parser here
port = self.__get_open_port()
command.append(str(port))
process = self.__try_startup(command)
# Handle Std out from the subprocess.
self.__stdout = Queue()
self.__stderr = Queue()
Thread(target=self.__enqueue_output,
args=(process.stdout, self.__stdout),
daemon=True).start()
Thread(target=self.__enqueue_output,
args=(process.stderr, self.__stderr),
daemon=True).start()
# Py4j connect to the started process.
gwp = GatewayParameters(port=port, eager_load=True)
self.java_gateway = JavaGateway(gateway_parameters=gwp,
java_process=process)
async def on_startup(app):
thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=16)
app['thread_pool'] = thread_pool
port = launch_gateway(
jarpath='/spark-2.4.0-bin-hadoop2.7/jars/py4j-0.10.7.jar',
classpath='/spark-2.4.0-bin-hadoop2.7/jars/*:/hail.jar',
die_on_exit=True)
gateway = JavaGateway(gateway_parameters=GatewayParameters(port=port),
auto_convert=True)
app['gateway'] = gateway
hail_pkg = getattr(gateway.jvm, 'is').hail
app['hail_pkg'] = hail_pkg
jbackend = hail_pkg.backend.service.ServiceBackend.apply()
app['jbackend'] = jbackend
jhc = hail_pkg.HailContext.apply(jbackend, 'hail.log', False, False, 50,
False, 3)
app['jhc'] = jhc
app['users'] = set()
kube.config.load_incluster_config()
k8s_client = kube.client.CoreV1Api()
app['k8s_client'] = k8s_client
def search(query, port): """Sends the given query string to the running DocFetcher instance at the given port and returns a list of result objects. The result objects provide the following getter methods for accessing their attributes: - getAuthors - getDateStr - e-mail send date - getFilename - getLastModifiedStr - last-modified date on files - getPathStr - file path - getScore - result score as int - getSender - e-mail sender - getSizeInKB - file size as int - getTitle - getType - isEmail - boolean indicating whether result object is e-mail or file This method will throw an error if communication with the DocFetcher instance fails. """ from py4j.java_gateway import JavaGateway, GatewayParameters from py4j.java_gateway import java_import gateway = JavaGateway(gateway_parameters=GatewayParameters(port=port)) java_import(gateway.jvm, "net.sourceforge.docfetcher.gui.Application") application = gateway.jvm.net.sourceforge.docfetcher.gui.Application indexRegistry = application.getIndexRegistry() searcher = indexRegistry.getSearcher() results = searcher.search(query) return results
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 __init__(self, n=3):
"Set up initial board configuration."
gateway = JavaGateway(
gateway_parameters=GatewayParameters(port=4242),
callback_server_parameters=CallbackServerParameters())
manager = gateway.entry_point
