def start_controller_actor(
host_name,
port,
minisat,
sugar_jar,
tmp_folder,
actor_uris,
log_requests,
skip_actor_response_test,
worker_count=None,
dry_run=False,
):
csp_solver_config = csp_solver.get_valid_csp_solver_config(
minisat_path=minisat, sugarjar_path=sugar_jar, tmp_folder=tmp_folder)
actors = [RemoteActor(actor_uri) for actor_uri in actor_uris]
pool_kwargs = {}
if worker_count:
pool_kwargs['processes'] = worker_count
import multiprocessing
pool = multiprocessing.Pool(**pool_kwargs)
actor = ControllerActor(actors=actors,
csp_solver_config=csp_solver_config,
multiprocessing_pool=pool)
if not skip_actor_response_test:
# test is actors of a ControllerActor exist
# to prevent errors later
for actor in actor._actors:
import urllib2
try:
value = actor.get_value()
assert type(value) == int
except urllib2.URLError as exc:
print("Error while checking {0}: {1}".format(
actor, exc.reason))
import sys
sys.exit(1)
print("All actors exist and respond as expected")
kw = dict(host_port_tuple=(host_name, port),
actor=actor,
log_requests=log_requests)
if dry_run:
print("Would start an actor controller on {0} "
"but this is a test run".format(kw))
return kw
try:
start_actor_server(**kw)
except KeyboardInterrupt:
pool.terminate()
except Exception:
pool.terminate()
finally:
pool.join()
def setUp(self):
uri1, self._actor_server_process_1 = start_actor_server(
start_in_background_thread=True,
actor=Actor(value_range=[1, 2, 3]))
uri2, self._actor_server_process_2 = start_actor_server(
start_in_background_thread=True,
actor=ControllerActor(
actors=[RemoteActor(uri=uri1)],
csp_solver_config=csp_solver_config,
))
self.a1 = RemoteActor(uri=uri2)
time.sleep(.8)
def setUp(self):
uri, self._actor_server_process = start_actor_server(
start_in_background_thread=True,
actor=Actor(value_range=[1,2,3])
)
self.a1 = RemoteActor(uri=uri)
time.sleep(.8)
def setUp(self):
uri1, self._actor_server_process_1 = start_actor_server(
start_in_background_thread=True,
actor=Actor(value_range=[1,2,3])
)
uri2, self._actor_server_process_2 = start_actor_server(
start_in_background_thread=True,
actor=ControllerActor(
actors=[
RemoteActor(uri=uri1)
],
csp_solver_config=csp_solver_config,
)
)
self.a1 = RemoteActor(uri=uri2)
time.sleep(.8)
def setUp(self):
uri, self._actor_server_process = start_actor_server(
start_in_background_thread=True,
actor=Actor(value_range=[1, 2, 3]))
# url ends with a '/'! --> test how /vr/ url is created
self.a1 = RemoteActor(uri=uri)
time.sleep(.8)
def setUp(self):
uri, self._actor_server_process = start_actor_server(
start_in_background_thread=True,
actor=Actor(value_range=[1,2,3])
)
# url ends with a '/'! --> test how /vr/ url is created
self.a1 = RemoteActor(uri=uri)
time.sleep(.8)
def setUp(self):
self.vr = [1, 2]
self.a1 = Actor(value_range=self.vr, value=1)
self.uri, server_process = start_actor_server(
actor=self.a1,
start_in_background_thread=True
)
self.processes = [server_process]
def start_the_actor_server(
host_name,
port,
value_range,
value,
log_requests,
dry_run=False,
use_wsgiref_server=False
):
kw = {
'host_port_tuple': (host_name, port),
'actor': create_actor(value_range=value_range, value=value),
'log_requests': log_requests,
'server_starter': start_wsgiref_server \
if use_wsgiref_server else start_bjoern_server
}
if dry_run:
print(u"DRY RUN with parameters Parameters: {0}".format(kw))
return kw
start_actor_server(**kw)
def start_controller_actor(
host_name,
port,
minisat,
sugar_jar,
tmp_folder,
actor_uris,
log_requests,
skip_actor_response_test,
worker_count=None,
dry_run=False,
):
csp_solver_config = csp_solver.get_valid_csp_solver_config(
minisat_path=minisat,
sugarjar_path=sugar_jar,
tmp_folder=tmp_folder
)
actors=[RemoteActor(actor_uri)
for actor_uri in actor_uris]
pool_kwargs = {}
if worker_count:
pool_kwargs['processes'] = worker_count
import multiprocessing
pool = multiprocessing.Pool(**pool_kwargs)
actor = ControllerActor(
actors=actors,
csp_solver_config=csp_solver_config,
multiprocessing_pool=pool
)
if not skip_actor_response_test:
# test is actors of a ControllerActor exist
# to prevent errors later
for actor in actor._actors:
import urllib2
try:
value = actor.get_value()
assert type(value) == int
except urllib2.URLError as exc:
print("Error while checking {0}: {1}".format(actor, exc.reason))
import sys
sys.exit(1)
print("All actors exist and respond as expected")
kw = dict(
host_port_tuple=(host_name, port),
actor=actor,
log_requests=log_requests
)
if dry_run:
print("Would start an actor controller on {0} "
"but this is a test run".format(kw))
return kw
try:
start_actor_server(**kw)
except KeyboardInterrupt:
pool.terminate()
except Exception:
pool.terminate()
finally:
pool.join()
def setUp(self):
uri, self._actor_server_process = start_actor_server(
start_in_background_thread=True,
actor=Actor(value_range=[1, 2, 3]))
self.a1 = RemoteActor(uri=uri)
time.sleep(.8)
def start_actor_servers(
number,
host_name,
# actor params
value_range,
value=None,
start_port=None,
exclude_ports=None,
save_to_json=None,
callback_uri=None,
force=False,
stop_servers_after_json_save=False # for testing
):
# handling of host_name is inconsistent: only used if
# start_port is set.
if start_port:
port_range = range(start_port,
start_port+number)
if exclude_ports:
for exclude_port in exclude_ports:
if exclude_port in port_range:
port_range.append(max(port_range)+1)
port_range.remove(exclude_port)
print("Starting {0} servers: {1} --> {2}. excluded {3}".format(
len(port_range), min(port_range), max(port_range),
', '.join(str(e) for e in exclude_ports)))
else:
print("Starting {0} servers: {1} --> {2}".format(
len(port_range),min(port_range),max(port_range)))
servers_to_start = []
for port in port_range:
servers_to_start.append({
'host_port_tuple':(host_name, port),
'actor':create_actor(value_range=value_range, value=value)
})
else:
servers_to_start = [
{'actor':create_actor(value_range=value_range, value=value)}
for _ in range(number)
]
lst_of_started_servers = [
# will respond with
# (real_host_name, port), process
start_actor_server(
start_in_background_thread=True,
**kw
)
for kw in servers_to_start
]
print("{0} servers started".format(len(lst_of_started_servers)))
lst_of_started_servers_uris = [
uri for uri, _process in lst_of_started_servers
]
if save_to_json:
print("Saving used ports to file '{0}'".format(save_to_json))
json_content = json.dumps(lst_of_started_servers_uris)
save_to_file(save_to_json, json_content, force=force)
if callback_uri:
print("POST to callback URI '{0}': {1}".format(
callback_uri,
lst_of_started_servers_uris
))
request = urllib2.Request(
callback_uri,
# a request containing "data" will be a POST request
data=json.dumps(lst_of_started_servers_uris)
)
try:
resp = urllib2.urlopen(request)
if resp.code == 200:
print("POST successful.")
except urllib2.URLError as exc:
print(exc)
print("Error connecting to callback URI!")
if stop_servers_after_json_save:
for _, process in lst_of_started_servers:
process.terminate()
return lst_of_started_servers
try:
print("I am done starting. Now waiting for "
"KeyboardInterrupt or SystemExit.")
import time
while True:
time.sleep(600)
except (KeyboardInterrupt, SystemExit):
print("Exiting...")
