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()
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
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()
def init(self, args, opts):
if opts.debug:
Debugger().register(self)
if ":" in opts.bind:
address, port = opts.bind.split(":")
port = int(port)
else:
address, port = opts.bind, 8000
node = Node().register(self)
node.add('peer_name', address, port)
def init(self, args, opts):
if opts.debug:
Debugger().register(self)
if ":" in opts.bind:
address, port = opts.bind.split(":")
port = int(port)
else:
address, port = opts.bind, 8000
auto_remote_event = {
'increment': '*'
}
node = Node().register(self)
node.add('peer_name', address, port, auto_remote_event=auto_remote_event)
def app(request, manager, watcher, bind):
app = App().register(manager)
node = Node().register(app)
watcher.wait('ready')
child = (App() + Node(port=bind[1], server_ip=bind[0]))
child.start(process=True)
node.add('child', *bind)
watcher.wait('connected')
def finalizer():
child.stop()
request.addfinalizer(finalizer)
return app
def app(request, manager, watcher, bind):
app = App().register(manager)
node = Node().register(app)
watcher.wait("ready")
child = App() + Node(port=bind[1], server_ip=bind[0])
child.start(process=True)
node.add("child", *bind)
watcher.wait("connected")
def finalizer():
child.stop()
request.addfinalizer(finalizer)
return app
def init(self, args, opts):
if opts.debug:
Debugger().register(self)
if ":" in opts.bind:
address, port = opts.bind.split(":")
port = int(port)
else:
address, port = opts.bind, 8000
auto_remote_event = {
'increment': '*'
}
node = Node().register(self)
node.add(
'peer_name', address, port, auto_remote_event=auto_remote_event)
def test_server_send_all(app, watcher, manager):
client1 = App().register(manager)
node1 = Node().register(client1)
chan = node1.add('client1', *app.bind)
assert watcher.wait('connected', channel=chan)
client2 = App().register(manager)
node2 = Node().register(client2)
chan = node2.add('client2', *app.bind)
assert watcher.wait('connected', channel=chan)
event = return_value()
app.server.send_all(event)
assert watcher.wait('return_value')
client1.unregister()
client2.unregister()
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()
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()
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()
def test_server_send(app, watcher, manager):
client1 = App().register(manager)
node1 = Node().register(client1)
chan1 = node1.add('client1', *app.bind)
assert watcher.wait('connected', channel=chan1)
client2 = App().register(manager)
node2 = Node().register(client2)
chan2 = node2.add('client2', *app.bind)
assert watcher.wait('connected', channel=chan2)
event = return_value()
app.server.send(event, app.server.get_socks()[0], no_result=True)
assert watcher.wait('return_value')
watcher.clear()
assert not watcher.wait('return_value')
client1.unregister()
client2.unregister()
def init(self, args, opts):
if opts.debug:
Debugger().register(self)
if ":" in opts.bind:
address, port = opts.bind.split(":")
port = int(port)
else:
address, port = opts.bind, 8000
self.node = Node(port=port, server_ip=address).register(self)
def test_server_send_multicast(app, watcher, manager):
client1 = App().register(manager)
node1 = Node().register(client1)
chan1 = node1.add('client1', *app.bind)
assert watcher.wait('connected', channel=chan1)
client2 = App().register(manager)
node2 = Node().register(client2)
chan2 = node2.add('client2', *app.bind)
assert watcher.wait('connected', channel=chan2)
client3 = App().register(manager)
node3 = Node().register(client3)
chan3 = node3.add('client3', *app.bind)
assert watcher.wait('connected', channel=chan3)
event = return_value()
app.server.send_to(event, app.server.get_socks()[:2])
assert watcher.wait('return_value')
event_cnt = 0
with watcher._lock:
for event in watcher.events:
if event.name == 'return_value':
event_cnt += 1
assert event_cnt == 2
client1.unregister()
client2.unregister()
client3.unregister()
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()
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 test_server_send(app, watcher, manager):
client1 = App().register(manager)
node1 = Node().register(client1)
chan1 = node1.add('client1', *app.bind)
assert watcher.wait('connected', channel=chan1)
client2 = App().register(manager)
node2 = Node().register(client2)
chan2 = node2.add('client2', *app.bind)
assert watcher.wait('connected', channel=chan2)
event = return_value()
app.server.send(event, app.server.get_socks()[0], no_result=True)
assert watcher.wait('return_value')
client1.unregister()
client2.unregister()
def test_server_send_all(app, watcher, manager):
client1 = App().register(manager)
node1 = Node().register(client1)
chan = node1.add('client1', *app.bind)
assert watcher.wait('connected', channel=chan)
client2 = App().register(manager)
node2 = Node().register(client2)
chan = node2.add('client2', *app.bind)
assert watcher.wait('connected', channel=chan)
event = return_value()
app.server.send_all(event)
assert watcher.wait('return_value')
client1.unregister()
client2.unregister()
def init(self, args, opts):
"""Initialize our ``ChatServer`` Component.
This uses the convenience ``init`` method which is called after the
component is proeprly constructed and initialized and passed the
same args and kwargs that were passed during construction.
"""
self.args = args
self.opts = opts
self.clients = {}
if opts.debug:
Debugger().register(self)
if ":" in opts.bind:
address, port = opts.bind.split(":")
port = int(port)
else:
address, port = opts.bind, 8000
Node(port=port, server_ip=address).register(self)
"""hello Event"""
class App(Component):
def ready(self, client):
print("Ready!")
def connected(self, host, port):
print("Connected to {}:{}".format(host, port))
print("Try: x = app.fire(hello())")
def hello(self):
print("Now try: y = app.fire(remote(hello(), \"test\"))")
return "Hello World! ({0:d})".format(getpid())
# Setup app1 with a debugger
app = App()
node = Node().register(app)
host = sys.argv[1]
port = int(sys.argv[2])
bind = (host, port)
# Add an address of a node to talk to called "test"
node.add("test", *bind)
# Start app as a thread
app.start()
