Problems using viznet.client.connect

[fordprefect]

No luck with an answer yet, so I look for a work-around myself. Extend the communication protocol with a connection-test and connect-confirm network events

import viz
import viznet

CONN_TEST = viznet.id("connTest")
CONN_CONF = viznet.id("connConf")

myName = viz.net.getName()

and, for testing reasons, just try to confirm a connection between MASTER and HEAD1, running the same script on each machine:

if myName == 'HEAD1':
    doClient()
else:
    doServer()

viz.go()

with the server part:

def srvrConnectTest(e):
    viznet.server.sendClient(e.client, CONN_CONF, server=myName)
    print 'connect confirmation sent'

def doServer():
    viznet.server.start()
    viz.callback(CONN_TEST, srvrConnectTest)

and the client code being:

import threading
_TIMEOUT = 3.0
_myServer = None
_confirmEvent = threading.Event()

def clntConnectConfirm(e):
    _myServer = e.server
    print 'received confirmation from', e.server
    _confirmEvent.set()

def doClient():
    _lookfor = 'MASTER'
    if not viznet.client.connect(_lookfor):
        print _lookfor, 'does not run'
    else:
        viz.callback(CONN_CONF, clntConnectConfirm)
        print 'asking for connection confirmation...'
        viznet.client.send(CONN_TEST, client=myName)
        _confirmEvent.clear()
        _confirmEvent.wait(_TIMEOUT)
        print 'the server's name is', _myServer

but this does not work as it seems that the event queue is only worked upon when the script is completed: the wait time on the Event is always used up, the server replies immediately and the client does only react on the event in the very end. (relevant) Output on the client is:

asking for connection confirmation...
the server's name is None
received confirmation from MASTER

Any idea what I have to do to get the information in time, when I need it, and not ages later??

Thanks,
Best Regards,
Walter

[farshizzo]

Hi,

A couple things to note:

• viznet currently uses UDP sockets for communication, not TCP. So there is no actual connection taking place. As long as the server address exists, it will report a successful "connection".
• Network message events are triggered during the main update loop, not asynchronously. So if you are blocking the main thread, then you won't be receiving any network events.

I'd recommend looking into the Python Twisted library. It supports much more advanced networking features.

However, you can perform a blocking handshake by manually updating the network events in a while loop. Here is a minimal example:

Server code:

import viz
import viznet
viz.go()

HANDSHAKE = viznet.id('ConnectHandshake')

viznet.server.start()

# Perform handshake with clients
def onStartClient(e):
	viznet.server.sendClient(e.sender,HANDSHAKE)
viz.callback(viznet.CLIENT_CONNECT_EVENT,onStartClient)

Client code:

import viz
import viznet
import vizact
viz.go()

SERVER = 'MASTER'

HANDSHAKE = viznet.id('ConnectHandshake')

def ConnectServer(server,timeout=2.0):
	d = viz.Data(connected=False)
	if viznet.client.connect(server):
		def _handshake(e):
			d.connected = True
		cb = vizact.addCallback(HANDSHAKE,_handshake)
		expire = viz.tick() + timeout
		while not d.connected and viz.tick() < expire:
			viz.waitTime(0.1)
			viz.update(viz.UPDATE_NETWORK)
		cb.remove()
	return d.connected

if ConnectServer(SERVER):
	print 'Connected'
else:
	print 'Not Connected'

Hope that is helpful.