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 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 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 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
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 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 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()
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 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()
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))
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)
# Kill the coordinator and shut down the actor system
def stop(sig, frame):
# global stopped
# stopped = True
global controller
asys.tell(controller, ActorExitRequest())
asys.shutdown()
