python twisted

class UDPClient(protocol.DatagramProtocol):

    def __init__(self, server_host, server_port, payload_generator):
        self.server_host = server_host
        self.server_port = server_port
        self.payload_generator = payload_generator
        self.response_callback = None
        self.timeout_callback = None
        self.timeout = None

    def set_response_callback(self, response_callback):
        self.response_callback = response_callback

    def set_timeout_callback(self, timeout_delay, timeout_callback):
        self.timeout_delay = timeout_delay
        self.timeout_callback = timeout_callback

    def startProtocol(self):
        print "Sending UDP request to SignalServer"
        self.transport.connect(self.server_host, self.server_port)
        self.transport.write(self.payload_generator())
        if self.timeout_callback is not None:
            self.timeout = reactor.callLater(self.timeout_delay, self.timedout)
        print "Exiting startProtocol"

    def datagramReceived(self, datagram, addr):
        if self.timeout is not None:
            self.timeout.cancel()
        print "Received UDP response from SignalServer"
        print "Data : " + binascii.hexlify(datagram)
        self.transport.loseConnection()
        if self.response_callback is not None:
            reactor.callWhenRunning(self.response_callback, datagram)

    def timedout(self):
        print "Timed out while waiting for UDP response"
        reactor.callWhenRunning(self.timeout_callback)



if __name__ == '__main__':

    def get_signaling_payload():
        payload = [ 0x9, 0xb1]
        return bytearray(payload)

    udp_client = UDPClient('aa.bb.cc.dd', 1234, get_signaling_payload)
    import sys
    udp_client.set_response_callback(lambda x : sys.stdout.write(x))
    reactor.listenUDP(0, udp_client)
    reactor.run()