Esempio n. 1
0
def app(manager, watcher, bind):
    server = Node(port=bind[1], server_ip=bind[0])
    server.register(manager)
    server.bind = bind
    assert watcher.wait('registered', channel='node')

    return server
Esempio n. 2
0
def test_auto_reconnect(app, watcher, manager):
    # add client
    client = App().register(manager)
    node = Node().register(client)
    chan = node.add('client1', *app.bind, reconnect_delay=1, connect_timeout=1)
    assert watcher.wait('connected', channel=chan)

    # close server
    app.fire(close(), app.channel)
    assert watcher.wait('closed', channel=app.channel)

    app.unregister()
    assert watcher.wait('unregistered', channel=app.channel)


    for i in range(5):
        watcher.clear()
        assert watcher.wait('connect', channel=chan)
        assert watcher.wait('unreachable', channel=chan)

    # open server
    app = Node(port=app.bind[1], server_ip=app.bind[0])
    app.register(manager)

    assert watcher.wait('registered', channel=app.channel)
    assert watcher.wait('connected_to', channel=app.channel)

    client.unregister()
Esempio n. 3
0
def test_auto_reconnect(app, watcher, manager):
    # add client
    client = App().register(manager)
    node = Node().register(client)
    chan = node.add('client1', *app.bind, reconnect_delay=1, connect_timeout=1)
    assert watcher.wait('connected', channel=chan)
    watcher.clear()

    # close server
    app.fire(close(), app.channel)
    assert watcher.wait('closed', channel=app.channel)
    watcher.clear()

    # client gets an unreachable
    assert watcher.wait('connect', channel=chan)
    assert watcher.wait('unreachable', channel=chan)
    watcher.clear()

    # start a new server
    node2 = Node(port=app.bind[1], server_ip=app.bind[0])
    node2.register(manager)
    assert watcher.wait('ready', channel=node2.channel)
    watcher.clear()

    assert watcher.wait('connected', channel=chan)

    client.unregister()
Esempio n. 4
0
def app(manager, watcher, bind):
    server = Node(port=bind[1], server_ip=bind[0])
    server.register(manager)
    server.bind = bind
    assert watcher.wait('registered', channel='node')

    return server
Esempio n. 5
0
def test_auto_reconnect(app, watcher, manager):
    # add client
    client = App().register(manager)
    node = Node().register(client)
    chan = node.add('client1', *app.bind, reconnect_delay=1, connect_timeout=1)
    assert watcher.wait('connected', channel=chan)

    # close server
    app.fire(close(), app.channel)
    assert watcher.wait('closed', channel=app.channel)

    app.unregister()
    assert watcher.wait('unregistered', channel=app.channel)

    for _ in range(5):
        watcher.clear()
        assert watcher.wait('connect', channel=chan)
        assert watcher.wait('unreachable', channel=chan)

    # open server
    app = Node(port=app.bind[1], server_ip=app.bind[0])
    app.register(manager)

    assert watcher.wait('registered', channel=app.channel)
    assert watcher.wait('connected_to', channel=app.channel)

    client.unregister()
Esempio n. 6
0
class Client(Network_Node, circuits.core.BaseComponent):
    def __init__(self, host="0.0.0.0", port=50552, socket=None):
        super().__init__()
        self.node = Node((self.host, self.port))
        self.node.register(self)
        self.socket = socket
        #This is the channel that the server's client is listening on.
        #The fact that I have to use this to talk exclusively to the server strongly
        #suggests that either circuits' API is all sorts of broken or I horribly misunderstand
        #it
        #This is GROOOOOSSSS
        self.server_channel = ""
        #Eventually, I'll need to grab player name somehow.
        self.player = Player()
    def connect(self, host="0.0.0.0", port=50551):
        self.node.add("server", host, port)
        self.server_channel = sha256("{0:s}:{1:d}".format(host, port).encode("utf-8")
                                    ).hexdigest()
    @circuits.handler("connected")
    def connected(self, host, port):
        #self.fire(remote(write(Join_Event(self.player).bytify()), "server"))
        self.fire(write(bytify(Join_Event(self.player))), self.server_channel)
    def go(self):
        self.gui = views.GUI()
        debug("Made gui")
        self.gui.first_view_class = views.Login_View
        self.start()
        debug("Srtarting gui")
        self.gui.run()
        debug("Started")

    def update(self):
        self.game.update()
Esempio n. 7
0
class Server(Network_Node, circuits.core.BaseComponent):
    def __init__(self, host="0.0.0.0", port=50551):
        super().__init__(host=host, port=port)
        #This maps user_id to client
        self.clients = {}
        #This is a temporary design. Ultimately this will be part of a client.
        #This is just here until clients are implemented
        #TODO: I'm from future and I don't remember what
        #this is talking about. Please investigate.
        self.sockets = set()
        self.id_generator = count()
        self.node = Node((self.host, self.port))
        self.node.register(self)
        self.id_generator = count() 
            
    @circuits.handler("connect")
    def connect(self, socket, host, port):
        self.sockets.add(socket)
        client = Client(host, port, socket=socket)
        self.clients[next(self.id_generator)] = client
    
    @circuits.handler("disconnect")
    def disconnect(self, socket):
        #This is an intentionally local event
        print("Updating code")
        events.Update_Code_Event().handle(self)

    def broadcast(self, event, exclude_list=None):
        exclude_list = exclude_list or []
        for client in filter(lambda client: client not in exclude_list,
                            self.clients.values()):
            self.fire(write(client.socket, bytify(event).encode("utf-8")))
    
    def cleanup(self):
        self.node.stop()
        self.stop()
    
    def shutdown(self):
        self.cleanup()
        #the fact that it tries to do this is gross.
        #Will need to replace the functionality somehow.
        #sys.exit(1)
    def restart(self):
        self.cleanup()