def test_tell(self):
asys = ActorSystem('multiprocQueueBase')
source = asys.createActor(DoTestSource)
targ = asys.createActor(DoTestTarget)
msg = SourceMessage("Hello From Source", target=targ, sender=source)
logging.info("Sending {}".format(str(msg)))
asys.tell(targ, msg)
def spawn(sys_base, app_id):
asys = ActorSystem(sys_base)
clerk = asys.createActor(Clerk, globalName="clerk-%d" % app_id)
asys.ask(
clerk,
Clerk.View(
asys.createActor(DirectoryServer, globalName="directory-server"),
KEYSPACE,
))
for i in range(0, 5):
oids = set()
while len(oids) != 10:
key_ = random.randint(1, KEYSPACE)
if key_ in oids:
continue
oids.add(key_)
success = False
while not success:
time.sleep(0.5)
trx = asys.ask(clerk, Clerk.Read(list(oids)))
if trx is False:
continue
mods = random.sample(oids, 5)
for mod in mods:
trx.write_set[mod] = app_id
logging.debug("Clients initialized")
success = asys.ask(clerk, Clerk.Commit(trx))
print(success)
time.sleep(2)
asys.tell(clerk, ActorExitRequest())
def start(sys_base):
asys = ActorSystem(sys_base, logDefs=logcfg)
ds = asys.createActor(DirectoryServer, globalName="directory-server")
db_servers = {}
for i in range(0, REPLICAS):
name = "db-server-%d" % i
db_servers[name] = asys.createActor(Server, globalName=name)
clusters = []
server_list = list(db_servers.keys())
for i in range(0, CLUSTER_COUNT):
cluster = Cluster(
"cluster-{}".format(i),
server_list[i * CLUSTER_SIZE:i * CLUSTER_SIZE + CLUSTER_SIZE])
clusters.append(cluster)
cluster_map = {}
for key in range(1, KEY_SPACE + 1):
cluster_map[key] = clusters[key % CLUSTER_COUNT]
asys.ask(ds, DirectoryServer.WhoServes(cluster_map))
grouped_cluster_map = _group_by_cluster(cluster_map)
for cluster, oid_set in grouped_cluster_map.items():
for server_name in cluster.members:
asys.ask(db_servers[server_name],
Server.View(oid_set, cluster, "directory-server"))
def test_ask(self):
print("Testing ask")
asys = ActorSystem('multiprocQueueBase')
source = asys.createActor(DoTestSource)
targ = asys.createActor(DoTestTarget)
msg = SourceAsk("Hello From Source", target=targ, sender=source)
logging.info("Sending {}".format(str(msg)))
print(asys.ask(targ, msg))
asys.shutdown()
class ConventionTests(unittest.TestCase):
def setUp(self):
self.sys1 = None
self.sys2 = None
self.sys2_capabilities = None
self.sys1_capabilities = None
print("Starting Main System")
self.sys1_capabilities = {
'Convention Address.IPv4': ('10.128.108.62', 2219),
'Admin Port': 2211
}
self.sys1 = ActorSystem('multiprocTCPBase',
capabilities=self.sys1_capabilities)
# Create the registrar on System 1 and send an Init Packet
self.registrar = self.sys1.createActor('ConventionLead.Registrar')
self.sys1.tell(self.registrar, messages.InitPacket())
def test_simple_message(self):
# Create System 2 and have it join the convention, this will force the registrar to create an actor on system2
self.sys2_capabilities = {
'Convention Address.IPv4': ('10.128.108.62', 2219),
'Admin Port': 2215,
'uuid': uuid.uuid4().hex
}
# the uuid is included here to uniquely identify system2 from other actor systems so the registrar can create
# an actor on this system
self.sys2 = ActorSystem(capabilities=self.sys2_capabilities)
print(self.sys2_capabilities)
try:
rn = self.sys2.createActor(
'Actors.RegistrarActor',
{'uuid': self.sys2_capabilities['uuid']},
globalName='rnode')
self.assertEqual(
rn, self.registrar.rnodes[self.sys2_capabilities['uuid']])
self.sys2.tell(rn, 'Hello String Me')
self.sys2.tell(rn, ActorExitRequest(True))
finally:
print("Shutting Down System 2")
self.sys2.shutdown()
def tearDown(self):
self.sys1.tell(self.registrar, ActorExitRequest())
self.sys1.shutdown()
def get_tickets(customer_id):
"""Get the tickets of a specific customer."""
try:
customer_id = request.headers.get('Customer-ID')
if not customer_id:
return jsonify({'error': "You do not have permissions."}), 403
asys = ActorSystem()
actor = asys.createActor(actorClass=CustomersActor)
customer_id = request.headers.get('Customer-ID')
order_date = request.args.get('order_date', default=None, type=float)
event_date = request.args.get('event_date', default=None, type=float)
payload = {
'customer_id':
int(customer_id),
'order_date':
datetime.fromtimestamp(order_date).date() if order_date else None,
'event_date':
datetime.fromtimestamp(event_date).date() if event_date else None
}
message = ActorMessage(action=CustomersActorAction.CUSTOMERS_TICKETS,
payload=payload,
customer_id=customer_id)
tickets_dict = []
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
for ticket in response.payload.get('tickets'):
tickets_dict.append(Ticket.to_dict(ticket))
return jsonify(tickets_dict)
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def start(sys_base):
asys = ActorSystem(sys_base, logDefs=logcfg)
ds = asys.createActor(DirectoryServer, globalName="directory-server")
db_servers = {}
for i in range(0, 5):
name = "db-server-%d" % i
db_servers[name] = asys.createActor(Server, globalName=name)
server_map = {
key: "db-server-%d" % (key % len(db_servers))
for key in range(1, KEY_SPACE + 1)
}
asys.ask(ds, DirectoryServer.WhoServes(server_map))
grouped_server_map = _group_by_server(server_map)
for server_name, key_set in grouped_server_map.items():
asys.ask(db_servers[server_name], Server.View(key_set))
def test_base_actor_state():
asys = ActorSystem("multiprocQueueBase")
base = asys.createActor(UtilTestActor)
state = asys.ask(base, "Get State")
asys.shutdown()
assert state is not None
assert state == ActorState.CREATED
class TestActors(TestCase):
def setUp(self) -> None:
self.asys = ActorSystem()
def tearDown(self) -> None:
self.asys.shutdown()
def test_child_actor(self):
searcher = SEARCHERS[0]
child_ac = self.asys.createActor(ChildActor)
result: dict = self.asys.ask(
child_ac, SearchRequest(searcher, "some text for find"))
self.assertIn(searcher, result.keys())
self.assertIsNotNone(result[searcher])
self.assertTrue(len(result[searcher]) > 0)
def test_master_actor1(self):
master = self.asys.createActor(MasterActor)
self.asys.tell(master, timedelta(milliseconds=500))
DummySearchClient.delay_for_dummy_search = 0.1
result = self.asys.ask(master, "some text for find")
s1 = list(SEARCHERS)
s2 = list(result.keys())
s1.sort()
s2.sort()
self.assertListEqual(s1, s2)
for s in SEARCHERS:
self.assertNotEqual(result[s], [])
def test_master_actor2(self):
master = self.asys.createActor(MasterActor)
self.asys.tell(master, timedelta(milliseconds=10))
DummySearchClient.delay_for_dummy_search = 1
result = self.asys.ask(master, "some text for find")
s1 = list(SEARCHERS)
s2 = list(result.keys())
s1.sort()
s2.sort()
self.assertListEqual(s1, s2)
for s in SEARCHERS:
self.assertEqual(result[s], [])
def start_thor(sys_base):
asys = ActorSystem(sys_base, logDefs=logcfg)
# ds = asys.createActor(DirectoryServer, globalName="directory-server")
db_servers = {}
for i in range(0, 3):
name = "server-%d" % i
db_servers[name] = asys.createActor(Server, globalName=name)
for server in db_servers.values():
asys.ask(server, Server.View({}, list(db_servers.values())))
def main():
max_wait = timedelta(seconds=10)
#system = ActorSystem('multiprocTCPBase')
system = ActorSystem()
parent = system.createActor(ParentProcessor)
system.tell(parent, 1)
print(system.listen(max_wait))
def main():
asys = ActorSystem()
try:
while True:
print("Type what you want to search:")
query = input()
master = asys.createActor(MasterActor, globalName="master")
res = asys.ask(master, query, timeout=timedelta(seconds=5))
print(res)
asys.tell(master, ActorExitRequest())
finally:
asys.shutdown()
class Coordinator():
def __init__(self):
self.actor_system = ActorSystem('multiprocQueueBase')
self.command_handler = CommandHandler(self)
self.display_handler = DisplayHandler(self.get_new_game_data,
self.command_handler)
self.resource_manager: Actor = self.actor_system.createActor(
ResourceManager, globalName="resource_manager")
self.technology_manager: Actor = self.actor_system.createActor(
TechnologyManager, globalName="technology_manager")
self.game_state_manager: Actor = self.actor_system.createActor(
GameStateManager, globalName="game_state_manager")
self.worker_manager: Actor = self.actor_system.createActor(
WorkerManager, globalName="worker_manager")
self.building_manager: Actor = self.actor_system.createActor(
BuildingManager, globalName="building_manager")
self.actors: List[Actor] = [
self.resource_manager,
self.technology_manager,
self.game_state_manager,
self.worker_manager,
self.building_manager,
]
def start_game(self):
# Start the active actors
self.actor_system.tell(self.game_state_manager, Start())
self.actor_system.tell(self.worker_manager, Start())
# Call into display manager - this is completely blocking
self.display_handler.do_display()
def end_game(self):
for a in self.actors:
self.actor_system.tell(a, ActorExitRequest())
def get_new_game_data(self) -> GameData:
return self.actor_system.ask(self.game_state_manager,
GameStateRequest())
def main(systembase):
actor_name = sys.argv[0].split('.')[0]
behavior = sys.argv[1]
capabilities = get_capability(actor_name, behavior)
asys = ActorSystem(systembase, capabilities=capabilities, logDefs=logcfg)
#asys.updateCapability("LEADER", 'yes')
actor_ignition = asys.createActor(Actor_Ignition) # , globalName=hostname)
logging.info("Igniting the system!")
asys.tell(actor_ignition, "start")
while True:
try:
time.sleep(2.0)
except KeyboardInterrupt:
asys.shutdown()
def get_sales():
"""Get the number of tickets sold per event."""
try:
customer_id = request.headers.get('Customer-ID')
if customer_id:
return jsonify({'error': "You do not have permissions."}), 403
asys = ActorSystem()
actor = asys.createActor(actorClass=EventsActor)
message = ActorMessage(action=EventsActorAction.EVENTS_SALES)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
return jsonify(response.payload.get('sales_dict'))
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def get(event_id):
"""Get event by ID."""
try:
customer_id = request.headers.get('Customer-ID')
asys = ActorSystem()
actor = asys.createActor(actorClass=EventsActor)
payload = {'event_id': int(event_id)}
message = ActorMessage(action=EventsActorAction.EVENTS_GET,
payload=payload,
customer_id=customer_id)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
return jsonify(Event.to_dict(response.payload.get('event')))
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def add():
"""Add a new event."""
try:
customer_id = request.headers.get('Customer-ID')
if customer_id:
return jsonify({'error': "You do not have permissions."}), 403
asys = ActorSystem()
actor = asys.createActor(actorClass=EventsActor)
event = Event.from_json(request.get_json())
payload = {'event': event}
message = ActorMessage(action=EventsActorAction.EVENTS_ADD,
payload=payload)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
return '', 204
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def index():
"""Get event list."""
try:
customer_id = request.headers.get('Customer-ID')
asys = ActorSystem()
actor = asys.createActor(actorClass=EventsActor)
message = ActorMessage(action=EventsActorAction.EVENTS_LIST,
customer_id=customer_id)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
events = response.payload.get('events')
events_dict = []
for event in events:
events_dict.append(Event.to_dict(event))
return jsonify(events_dict)
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def add():
"""Add a new customer."""
try:
customer_id = request.headers.get('Customer-ID')
if customer_id:
return jsonify({'error': "You do not have permissions."}), 403
asys = ActorSystem()
actor = asys.createActor(actorClass=CustomersActor)
customer = Customer.from_json(request.get_json())
payload = {'customer': customer}
message = ActorMessage(action=CustomersActorAction.CUSTOMERS_ADD,
payload=payload,
customer_id=customer_id)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
return jsonify(response.payload)
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def purchase(event_id):
"""Purchase tickets for a specific event."""
try:
customer_id = request.headers.get('Customer-ID')
if not customer_id:
return jsonify({'error': "You do not have permissions."}), 403
asys = ActorSystem()
actor = asys.createActor(actorClass=EventsActor)
customer_id = request.headers.get('Customer-ID')
payload = {
'event_id': int(event_id),
'quantity': int(request.get_json().get('quantity'))
}
message = ActorMessage(action=EventsActorAction.EVENTS_PURCHASE,
payload=payload,
customer_id=customer_id)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
return '', 204
except Exception as ex:
return jsonify({'error': str(ex)}), 500
def get_budget(customer_id):
"""Get the budget of a specific customer."""
try:
if not customer_id:
return jsonify({'error': "You do not have permissions."}), 403
if not customer_id == request.headers.get('Customer-ID'):
return jsonify({'error': "You do not have permissions."}), 403
asys = ActorSystem()
actor = asys.createActor(actorClass=CustomersActor)
customer_id = request.headers.get('Customer-ID')
payload = {
'customer_id': int(customer_id),
'year': request.args.get('year', default=None, type=int)
}
message = ActorMessage(action=CustomersActorAction.CUSTOMERS_BUDGET,
payload=payload,
customer_id=customer_id)
response = asys.ask(actor, message)
if response.error:
return jsonify({'error': str(response.error.message)
}), response.error.http_code
return jsonify(response.payload)
except Exception as ex:
return jsonify({'error': str(ex)}), 500
events = pygame.event.get()
for event in events:
if event.type == MOUSEBUTTONUP:
self.send(
self.clickNotifier, ClickData(event.pos, self.itemsToDraw, ActorExitRequest(), self.myAddress)
)
elif event.type == KEYDOWN:
ant_type = {pygame.K_b: BlackAntSpriteActor, pygame.K_r: RedAntSpriteActor}.get(event.key, None)
if ant_type:
sprite = self.createActor(ant_type)
self.send(sprite, StartSprite(self.myAddress, []))
elif event.type == QUIT:
print("QUIT")
pygame.quit()
self.send(self.origSender, "STOP")
self.send(self.myAddress, ActorExitRequest())
def _create_text_obj(self, centerLoc=(SURFACE_X_SIZE / 2, SURFACE_Y_SIZE / 2), text=""):
font_obj = pygame.font.Font("freesansbold.ttf", 32)
self.textSurfaceObj = font_obj.render(text, True, GREEN, BLUE)
self.textRectObj = self.textSurfaceObj.get_rect()
self.textRectObj.center = (centerLoc[0], centerLoc[1])
asys = ActorSystem("multiprocQueueBase")
drawerActor = asys.createActor(DrawerActor)
asys.ask(drawerActor, "start")
print("COMPLETE")
asys.shutdown()
('WatchFolders', watch_folders), ('HostName', hostname),
('HandBrakeCLI', handbrake_exists())])
print(capabilities)
# Creates Actor System
asys = ActorSystem('multiprocTCPBase', capabilities, logDefs=LogConfig)
# Set a variable that watches for a stop signal from the system
# stopped = False
# If we are the convention leader, set up the coordinator and have it watch for
# convention updates
if host_address == convention_leader:
# print("I'm the convention leader, let's create a Master Controller")
controller = asys.createActor('mmr.Coordinator', globalName='Coordinator')
asys.tell(controller, messages.Initialize(capabilities=capabilities))
# print("Telling the master to watch for convention registration changes")
# print("Now tell the master controller to create a node controller on my system")
node_controller = asys.ask(controller,
messages.CreateNodeController(hostname))
# print(node_controller)
# while controller:
# print(controller)
# controller = asys.listen(timedelta(seconds=1.0))
# sys.exit(0)
import time
import signal
import uuid
import messages
capabilities = {'Convention Address.IPv4': ('10.128.108.62', 2212), 'Admin Port': 2212}
def signal_handler(sig, frame):
print('Shutting Down')
asys = ActorSystem('multiprocTCPBase', capabilities)
asys.tell(la, ActorExitRequest)
asys.shutdown()
exit(0)
def startup():
signal.signal(signal.SIGINT, signal_handler)
if __name__ == "__main__":
print(capabilities)
asys = ActorSystem('multiprocTCPBase', capabilities)
la = asys.createActor('ConventionLead.Registrar')
asys.tell(la, messages.InitPacket())
time.sleep(15)
print("Shutting Down")
asys.tell(la, ActorExitRequest)
time.sleep(3)
asys.shutdown()
class Supervisor:
"""
Interface with Actor system
Used to launch, stop and monitor actors
"""
def __init__(self, verbose_mode: bool):
"""
:param verbose_mode: Specify the log level : True -> DEBUG False -> INFO
"""
if verbose_mode:
LOG_DEF['handlers']['h1']['level'] = logging.DEBUG
LOG_DEF['handlers']['h2']['level'] = logging.DEBUG
else:
LOG_DEF['handlers']['h1']['level'] = logging.INFO
LOG_DEF['handlers']['h2']['level'] = logging.INFO
self.system = ActorSystem(systemBase='multiprocQueueBase',
logDefs=LOG_DEF)
self.pushers = {}
self.pullers = {}
self.dispatchers = {}
self.actors = {}
def launch(self, actor_cls: Type[Actor], start_message: StartMessage):
"""
create an actor from a given class and send it a start message.
:param actor_cls: class used to create the actor
:param start_message: message used to initialize the actor
:raise InitializationException: if an error occurs during actor initialiszation process
"""
name = start_message.name
address = self.system.createActor(actor_cls)
answer = self.system.ask(address, start_message)
if isinstance(answer, OKMessage):
self._add_actor(address, name, actor_cls)
logging.info('launch %s actor', name)
return address
elif isinstance(answer, ErrorMessage):
raise InitializationException(answer.error_message)
raise InitializationException("Unknow message type : " +
str(type(answer)))
def _add_actor(self, address, name, actor_cls):
if issubclass(actor_cls, PusherActor):
self.pushers[name] = address
elif issubclass(actor_cls, PullerActor):
self.pullers[name] = address
elif issubclass(actor_cls, DispatcherActor):
self.dispatchers[name] = address
else:
raise AttributeError(
'Actor is not a DispatcherActor, PusherActor or PullerActor')
self.actors[name] = address
def _wait_actors(self):
for _ in self.pushers:
self.system.listen()
def shutdown(self):
"""
Shutdown the entire actor system and all the actors
"""
self.system.shutdown()
def monitor(self):
"""
wait for an actor to send an EndMessage or for an actor to crash
"""
while True:
msg = self.system.listen(1)
if msg is None:
pass
elif isinstance(msg, EndMessage):
self._wait_actors()
return
else:
logging.error("Unknow message type : %s", str(type(msg)))
import sys
from datetime import timedelta
from thespian.actors import ActorSystem
if __name__ == "__main__":
# We take the convention leaders address from the command line
# Also, we tag this system with "Client"
capabilities = {
"Convention Address.IPv4": (sys.argv[1], 1900),
"Client": True
}
actor_system = ActorSystem("multiprocTCPBase", capabilities)
# We create an actor from the echo library with class EchoRequestor
echo_app = actor_system.createActor("echo.EchoRequestor")
# Send the echo actor a message: the number of echo requests it should perform
actor_system.tell(echo_app, int(sys.argv[2]))
# Now, send the echo payload, and wait max. 10s for an answer
resp = actor_system.ask(echo_app, "hello world", timedelta(seconds=10))
while resp:
# If we get "echo_done" as an answer we break out
if resp == "echo_done":
break
# Otherwise we'll retry to get a response
print("unexpected message {}".format(resp))
resp = actor_system.listen(timedelta(seconds=10))
import socket
import errno
from datetime import timedelta
from functools import partial
from common import *
import Actors
import time
import signal
import uuid
#capabilities = {'Convention Address.IPv4': ('10.128.108.62', 2212), 'Admin Port': 2213, 'uuid': None}
capabilities = {'Admin Port': 2213, 'uuid': None}
if __name__ == "__main__":
capabilities['uuid'] = uuid.uuid4().hex
asys = ActorSystem('multiprocTCPBase', capabilities)
print("Joining Convention")
asys.updateCapability('Convention Address.IPv4', ('10.128.108.62', 2212))
time.sleep(2)
rn = asys.createActor('Actors.RegistrarActor',
{'uuid': capabilities['uuid']},
globalName='rnode')
asys.tell(rn, 'Hello String')
time.sleep(1)
# la = asys.createActor(Actors.LogActor)
# asys.tell(la,"init")
# time.sleep(2)
print("Shutting Down")
asys.tell(rn, ActorExitRequest())
time.sleep(3)
asys.shutdown()
from thespian.actors import ActorSystem, Actor, ValidateSource, ValidatedSource
import sys
portnum = int(sys.argv[1])
capability_names = (sys.argv + [''])[2].split(',')
capabilities = dict([('Admin Port', portnum),
('Convention Address.IPv4', ('', 1900)),
] +
list(zip(capability_names, [True] * len(capability_names))))
class SimpleSourceAuthority(Actor):
def receiveMessage(self, msg, sender):
if msg is True:
self.registerSourceAuthority()
if isinstance(msg, ValidateSource):
self.send(sender,
ValidatedSource(msg.sourceHash,
msg.sourceData,
# Thespian pre 3.2.0 has no sourceInfo
getattr(msg, 'sourceInfo', None)))
if __name__ == "__main__":
asys = ActorSystem('multiprocTCPBase', capabilities)
sa = asys.createActor(SimpleSourceAuthority)
asys.tell(sa, True) # cause source authority to register itself as such
class DistributedHGS(ComplexDriver):
def __init__(
self,
population,
dims,
fitnesses,
fitness_errors,
cost_modifiers,
driver,
mutation_etas,
crossover_etas,
mutation_rates,
crossover_rates,
reference_point,
mantissa_bits,
min_progress_ratio,
metaepoch_len=5,
max_level=2,
max_sprouts_no=20,
sproutiveness=1,
comparison_multipliers=(1.0, 0.1, 0.01),
population_sizes=(64, 16, 4),
*args,
**kwargs,
):
super().__init__(*args, **kwargs)
self.hgs_config = HgsConfig()
self.hgs_config.driver = driver
self.hgs_config.population = population
self.hgs_config.dims = dims
self.hgs_config.reference_point = reference_point
self.hgs_config.fitnesses = fitnesses
self.hgs_config.fitness_errors = fitness_errors
self.hgs_config.cost_modifiers = cost_modifiers
corner_a = np.array([x for x, _ in dims])
corner_b = np.array([x for _, x in dims])
corner_dist = np.linalg.norm(corner_a - corner_b)
self.hgs_config.min_dists = [
x * corner_dist for x in comparison_multipliers
]
logger.info(
f'multipliers: {comparison_multipliers}, min dists: {self.hgs_config.min_dists}'
)
self.hgs_config.metaepoch_len = metaepoch_len
self.hgs_config.max_level = max_level
self.hgs_config.max_sprouts_no = max_sprouts_no
self.hgs_config.sproutiveness = sproutiveness
self.hgs_config.min_progress_ratio = min_progress_ratio
self.hgs_config.mutation_etas = mutation_etas
self.hgs_config.mutation_rates = mutation_rates
self.hgs_config.crossover_etas = crossover_etas
self.hgs_config.crossover_rates = crossover_rates
self.hgs_config.population_sizes = population_sizes
self.hgs_config.mantissa_bits = mantissa_bits
self.hgs_config.driver_message_adapter_factory = (
self.driver_message_adapter_factory)
# TODO this is shared variable which is a problem in actor model
self.hgs_config.global_fitness_archive = [
tools.ResultArchive() for _ in range(3)
]
# TODO add preconditions checking if message adapter is HGS message adapter
logger.info("HGS CREATED")
self.hgs_system = ActorSystem()
self.node_supervisor = self.hgs_system.createActor(HgsNodeSupervisor)
self.hgs_system.ask(
self.node_supervisor,
HgsMessage(HgsOperation.START, data=self.hgs_config))
self.hgs_system.ask(self.node_supervisor,
HgsMessage(HgsOperation.CHECK_STATUS))
self.cost = 0
def shutdown(self):
self.hgs_system.tell(self.node_supervisor, ActorExitRequest())
def finalized_population(self):
return (ActorSystem().ask(self.node_supervisor,
HgsMessage(HgsOperation.POPULATION)).data)
def step(self):
epoch_end_message = ActorSystem().ask(
self.node_supervisor, HgsMessage(HgsOperation.NEW_METAEPOCH))
self.cost = epoch_end_message.data
ActorSystem().ask(self.node_supervisor,
HgsMessage(HgsOperation.TRIM_NOT_PROGRESSING))
ActorSystem().ask(self.node_supervisor,
HgsMessage(HgsOperation.TRIM_REDUNDANT))
ActorSystem().ask(self.node_supervisor,
HgsMessage(HgsOperation.RELEASE_SPROUTS))
ActorSystem().ask(self.node_supervisor,
HgsMessage(HgsOperation.REVIVE))
logger.info(f"step finished, current cost = {self.cost}")
from thespian.actors import ActorSystem, Actor, ValidateSource, ValidatedSource
import sys
portnum = int(sys.argv[1])
capability_names = (sys.argv + [''])[2].split(',')
capabilities = dict([('Admin Port', portnum),
('Convention Address.IPv4', ('', 1900)),
] +
list(zip(capability_names, [True] * len(capability_names))))
class SimpleSourceAuthority(Actor):
def receiveMessage(self, msg, sender):
if msg is True:
self.registerSourceAuthority()
if isinstance(msg, ValidateSource):
self.send(sender,
ValidatedSource(msg.sourceHash,
msg.sourceData,
# Thespian pre 3.2.0 has no sourceInfo
getattr(msg, 'sourceInfo', None)))
asys = ActorSystem('multiprocTCPBase', capabilities)
sa = asys.createActor(SimpleSourceAuthority)
asys.tell(sa, True) # cause source authority to register itself as such
