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()
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_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 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_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()
""" 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]) try:
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")
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)
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 try: while True: