def say_hello(self, message, main_actor, team_name, host=None, port=None):
""" Opens a connection to the remote main_actor,
and sends it a "hello" message with the given team_name.
"""
try:
if port is None:
# assume local game (TODO: put somewhere else?)
self.server_actor = actor_registry.get_by_name(main_actor)
else:
self.server_actor = RemoteConnection().actor_for(main_actor, host, port)
except DeadConnection:
# no connection could be established
self.ref.reply("failed")
if not self.server_actor:
_logger.warning("Actor %r not found." % main_actor)
return
try:
if self.server_actor.query("hello", [team_name, self.ref.uuid]).get(2) == "ok":
_logger.info("Connection accepted")
self.ref.reply("ok")
except Queue.Empty:
self.ref.reply("actor no reply")
def test_bad_json(self):
remote = RemoteConnection().start_listener("localhost", 0)
remote.register("main-actor", actor_of(MultiplyingActor))
# port is dynamic
port = remote.listener.socket.port
client = RemoteConnection().actor_for("main-actor", "localhost", port)
# unserialisable class
class SomeClass(object):
pass
somobj = SomeClass()
self.assertRaises(TypeError, client.query, "mult", somobj)
remote.stop()
def test_bad_actors(self):
remote = RemoteConnection().start_listener("localhost", 0)
remote.register("main-actor", actor_of(MultiplyingActor))
remote.start_all()
# port is dynamic
port = remote.listener.socket.port
# check a remote identifier which does not work
# should reply with an error message
client = RemoteConnection().actor_for("unknown-actor", "localhost", port)
req = client.query("mult", [1, 4, 4])
res = req.get(timeout=3)
self.assertTrue("error" in res)
remote.stop()
def test_not_running(self):
remote = RemoteConnection().start_listener("localhost", 0)
remote.register("main-actor", actor_of(MultiplyingActor))
# port is dynamic
port = remote.listener.socket.port
client = RemoteConnection().actor_for("main-actor", "localhost", port)
req = client.query("mult", [1, 4, 4])
res = req.get(timeout=3)
self.assertTrue("error" in res)
remote.stop()
def _setup(self):
""" Instantiates the ServerActor and initialises a new game.
"""
self.server = actor_of(ServerActor, "pelita-main")
if self.port is not None:
print "Starting remote connection on %s:%s" % (self.host, self.port)
self.remote = RemoteConnection().start_listener(host=self.host, port=self.port)
self.remote.register("pelita-main", self.server)
self.remote.start_all()
else:
print "Starting actor '%s'" % "pelita-main"
self.server.start()
self.server.notify("initialize_game", [self.layout, self.players, self.rounds])
class _ClientActor(DispatchingActor):
""" Actor used to communicate with the Server.
"""
def on_start(self):
self.team = None
self.server_actor = None
@expose
def register_team(self, message, team):
""" We register the team.
"""
# TODO: Maybe throw an exception, if a team
# is already registered.
# Also: investigate how to deal with concurrency issues
self.team = team
@expose
def say_hello(self, message, main_actor, team_name, host=None, port=None):
""" Opens a connection to the remote main_actor,
and sends it a "hello" message with the given team_name.
"""
try:
if port is None:
# assume local game (TODO: put somewhere else?)
self.server_actor = actor_registry.get_by_name(main_actor)
else:
self.server_actor = RemoteConnection().actor_for(main_actor, host, port)
except DeadConnection:
# no connection could be established
self.ref.reply("failed")
if not self.server_actor:
_logger.warning("Actor %r not found." % main_actor)
return
try:
if self.server_actor.query("hello", [team_name, self.ref.uuid]).get(2) == "ok":
_logger.info("Connection accepted")
self.ref.reply("ok")
except Queue.Empty:
self.ref.reply("actor no reply")
@expose
def set_bot_ids(self, message, *bot_ids):
""" Called by the server. This method sets the available bot_ids for this team.
"""
self.ref.reply(self.team._set_bot_ids(bot_ids))
@expose
def set_initial(self, message, universe):
""" Called by the server. This method tells us the initial universe.
"""
self.ref.reply(self.team._set_initial(universe))
@expose
def play_now(self, message, bot_index, universe):
""" Called by the server. This message requests a new move
from the bot with index `bot_index`.
"""
move = self.team._get_move(bot_index, universe)
self.ref.reply(move)
For all practical needs, using the simplesetup module should be sufficient.
"""
from pelita.messaging import actor_of, RemoteConnection
from pelita.actors import ServerActor
import logging
from pelita.ui.tk_viewer import TkViewer
from pelita.utils.colorama_wrapper import colorama
FORMAT = '[%(asctime)s,%(msecs)03d][%(name)s][%(levelname)s][%(funcName)s]' + colorama.Fore.MAGENTA + ' %(message)s' + colorama.Fore.RESET
#logging.basicConfig(format=FORMAT, datefmt="%H:%M:%S", level=logging.WARNING)
server = actor_of(ServerActor, "pelita-main")
remote = RemoteConnection().start_listener(host="", port=50007)
remote.register("pelita-main", server)
remote.start_all()
layout = (
""" ##################
#0#. . 2# . 3 #
# ##### ##### #
# . # . .#1#
################## """)
server.notify("initialize_game", [layout, 4, 200])
viewer = TkViewer()
server.notify("register_viewer", [viewer])
def test_connection(self):
remote = RemoteConnection().start_listener("localhost", 0)
remote_actor = actor_of(MultiplyingActor)
remote.register("main-actor", remote_actor)
remote.start_all()
# port is dynamic
port = remote.listener.socket.port
client = RemoteConnection().actor_for("main-actor", "localhost", port)
self.assertTrue(remote_actor.is_alive)
self.assertTrue(client.is_connected())
self.assertTrue(remote_actor.is_alive)
remote_actor.stop()
remote_actor.join()
# we are still connected
self.assertTrue(client.is_connected())
remote.stop()
# need to wait a little until the connection shuts down, sorry
for i in range(50):
still_connected = client.is_connected()
if still_connected:
time.sleep(0.1)
else:
return
self.assertFalse(still_connected)
def test_remote(self):
remote = RemoteConnection().start_listener("localhost", 0)
remote.register("main-actor", actor_of(MultiplyingActor))
remote.start_all()
# port is dynamic
port = remote.listener.socket.port
client1 = RemoteConnection().actor_for("main-actor", "localhost", port)
res = client1.query("mult", [1, 2, 3, 4])
self.assertEqual(res.get(timeout=3), 24)
# check, that I can use another client
client2 = RemoteConnection().actor_for("main-actor", "localhost", port)
res = client2.query("mult", [4, 4, 4])
self.assertEqual(res.get(timeout=3), 64)
# check, that the first still works
res = client1.query("mult", [2, 2, 4])
self.assertEqual(res.get(timeout=3), 16)
remote.stop()
self.ref.channel.notify("Pong", channel=self.ref)
self.pong_count += 1
@expose
def Stop(self, message):
print "Pong: Stop."
self.ref.put(StopProcessing)
import logging
#logging.basicConfig()
remote = True
if remote:
remote = RemoteConnection().start_listener("localhost", 0)
remote.register("ping", actor_of(Ping))
remote.start_all()
port = remote.listener.socket.port
ping = RemoteConnection().actor_for("ping", "localhost", port)
else:
ping = actor_of(Ping)
ping.start()
pong = actor_of(Pong)
pong.start()
ping.notify("connect", [pong.uuid])
ping.notify("Start")
def test_remote(self):
remote = RemoteConnection().start_listener("localhost", 0)
remote.register("main-actor", actor_of(MultiplyingActor))
remote.start_all()
# port is dynamic
port = remote.listener.socket.port
client1 = RemoteConnection().actor_for("main-actor", "localhost", port)
res = client1.query("mult", [1, 2, 3, 4])
self.assertEqual(res.get(timeout=3), 24)
# check, that I can use another client
client2 = RemoteConnection().actor_for("main-actor", "localhost", port)
res = client2.query("mult", [4, 4, 4])
self.assertEqual(res.get(timeout=3), 64)
# check, that the first still works
res = client1.query("mult", [2, 2, 4])
self.assertEqual(res.get(timeout=3), 16)
# check a remote identifier which does not work
# sorry, no error propagation at the moment,
# need to use a timeout
client2 = RemoteConnection().actor_for("unknown-actor", "localhost", port)
res = client2.query("mult", [1, 4, 4])
self.assertRaises(Queue.Empty, res.get, timeout=1)
remote.stop()
class SimpleServer(object):
""" Sets up a simple Server with most settings pre-configured.
Usage
-----
server = SimpleServer(layoutfile="mymaze.layout", rounds=3000, port=50007)
server.run_tk()
Parameters
----------
layout : string, optional
The layout as a string. If missing, a `layoutfile` must be given.
layoutfile : filename, optional
A file which holds a layout. If missing, a `layout` must be given.
players : int, optional
The number of Players/Bots used in the layout. Default: 4.
rounds : int, optional
The number of rounds played. Default: 3000.
host : string, optional
The hostname which the server runs on. Default: "".
port : int, optional
The port which the server runs on. Default: 50007.
local : boolean, optional
If True, we only setup a local server. Default: False.
"""
def __init__(self, layout=None, layoutfile=None, players=4, rounds=3000, host="", port=50007, local=False):
if layout is None:
if layoutfile:
with open(layoutfile) as file:
self.layout = file.read()
else:
self.layout = get_random_layout()
else:
self.layout = layout
self.players = players
self.rounds = rounds
if local:
self.host = None
self.port = None
else:
self.host = host
self.port = port
self.server = None
self.remote = None
def _setup(self):
""" Instantiates the ServerActor and initialises a new game.
"""
self.server = actor_of(ServerActor, "pelita-main")
if self.port is not None:
print "Starting remote connection on %s:%s" % (self.host, self.port)
self.remote = RemoteConnection().start_listener(host=self.host, port=self.port)
self.remote.register("pelita-main", self.server)
self.remote.start_all()
else:
print "Starting actor '%s'" % "pelita-main"
self.server.start()
self.server.notify("initialize_game", [self.layout, self.players, self.rounds])
def _run_save(self, main_block):
""" Method which executes `main_block` and rescues
a possible keyboard interrupt.
"""
self._setup()
try:
main_block()
except KeyboardInterrupt:
print "Server received CTRL+C. Exiting."
finally:
self.server.stop()
if self.remote:
self.remote.stop()
def run_ascii(self):
""" Starts a game with the ASCII viewer.
This method does not return until the server is stopped.
"""
def main():
viewer = AsciiViewer()
self.server.notify("register_viewer", [viewer])
# We wait until the server is dead
while self.server._actor.thread.is_alive:
self.server._actor.thread.join(1)
self._run_save(main)
def run_tk(self):
""" Starts a game with the Tk viewer.
This method does not return until the server or Tk is stopped.
"""
def main():
# Register a tk_viewer
viewer = TkViewer()
self.server.notify("register_viewer", [viewer])
# We wait until tk closes
viewer.app.mainloop()
self._run_save(main)
@expose
def slow_series(self, message, *params):
res = slow_series(*params)
self.ref.reply(res)
@expose
def random_int(self, message):
import random
self.ref.reply(random.randint(0, 10))
actor = actor_of(ClientActor)
actor.start()
port = 50007
remote_actor = RemoteConnection().actor_for("main-actor", "localhost", port)
res = remote_actor.query("multiply", [1, 2, 3, 4])
print res.get()
remote_actor.notify("hello", [str(actor.uuid)])
try:
while actor.is_alive:
actor.join(1)
except KeyboardInterrupt:
print "Interrupted"
actor.stop()
reqs = []
for player in self.players:
reqs.append( player.query("random_int", []) )
res = 0
for answer in reqs:
res += answer.get()
if res % 2 != 0:
self.ref.reply("Player 1 wins")
else:
self.ref.reply("Player 2 wins")
remote = RemoteConnection().start_listener("localhost", 50007)
actor_ref = actor_of(ServerActor)
remote.register("main-actor", actor_ref)
remote.start_all()
#incoming_bundler = IncomingConnectionsActor(incoming_connections, inbox)
#incoming_bundler.start()
def printcol(msg):
"""Using a helper function to get coloured output"""
print colorama.Fore.BLUE + str(msg) + colorama.Fore.RESET
class EndSession(Exception):
pass
import json
