def execute(address, command):
deferred = Deferred()
consumer = SingleItemConsumer(deferred)
protocol = HostapdControlProtocol(consumer, command=command)
consumer.registerProducer(protocol, True)
reactor.connectUNIXDatagram(address, protocol, bindAddress=protocol.bindAddress())
return deferred
def execute(address, command):
deferred = Deferred()
consumer = SingleItemConsumer(deferred)
protocol = HostapdControlProtocol(consumer, command=command)
consumer.registerProducer(protocol, True)
reactor.connectUNIXDatagram(address,
protocol,
bindAddress=protocol.bindAddress())
return deferred
def buildProtocol(self, address):
ws = ProducerConsumerWsProtocol()
ws.factory = self
control = HostapdControlProtocol(emit_json=False)
reactor.connectUNIXDatagram(self.control_interface, control,
bindAddress=control.bindAddress())
ws.consumer = control
control.consumer = ws
ws.registerProducer(control, True)
control.registerProducer(ws, True)
return ws
def buildProtocol(self, address):
ws = ProducerConsumerWsProtocol()
ws.factory = self
control = HostapdControlProtocol(emit_json=False)
reactor.connectUNIXDatagram(self.control_interface,
control,
bindAddress=control.bindAddress())
ws.consumer = control
control.consumer = ws
ws.registerProducer(control, True)
control.registerProducer(ws, True)
return ws
def test_exchange(self):
"""
Test that a datagram can be sent to and received by a server and vice
versa.
"""
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
self.addCleanup(s.stopListening)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress=clientaddr)
self.addCleanup(c.stopListening)
d = defer.gatherResults([sp.deferredStarted, cp.deferredStarted])
def write(ignored):
cp.transport.write(b"hi")
return defer.gatherResults(
[sp.deferredGotWhat, cp.deferredGotBack])
def _cbTestExchange(ignored):
self.assertEqual(b"hi", sp.gotwhat)
self.assertEqual(clientaddr, sp.gotfrom)
self.assertEqual(b"hi back", cp.gotback)
d.addCallback(write)
d.addCallback(_cbTestExchange)
return d
def test_exchange(self):
"""
Test that a datagram can be sent to and received by a server and vice
versa.
"""
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
self.addCleanup(s.stopListening)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress=clientaddr)
self.addCleanup(c.stopListening)
d = defer.gatherResults([sp.deferredStarted, cp.deferredStarted])
def write(ignored):
cp.transport.write(b"hi")
return defer.gatherResults([sp.deferredGotWhat,
cp.deferredGotBack])
def _cbTestExchange(ignored):
self.assertEqual(b"hi", sp.gotwhat)
self.assertEqual(clientaddr, sp.gotfrom)
self.assertEqual(b"hi back", cp.gotback)
d.addCallback(write)
d.addCallback(_cbTestExchange)
return d
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
d = defer.gatherResults([sp.deferredStarted, cp.deferredStarted])
def write(ignored):
cp.transport.write("hi")
return defer.gatherResults([sp.deferredGotWhat,
cp.deferredGotBack])
def cleanup(ignored):
d1 = defer.maybeDeferred(s.stopListening)
d1.addCallback(lambda x : os.unlink(clientaddr))
d2 = defer.maybeDeferred(c.stopListening)
d2.addCallback(lambda x : os.unlink(serveraddr))
return defer.gatherResults([d1, d2])
def _cbTestExchange(ignored):
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
d.addCallback(write)
d.addCallback(cleanup)
d.addCallback(_cbTestExchange)
return d
def openClientMode(self, iface=''):
try:
self._lport = reactor.connectUNIXDatagram(iface, self)
except Exception as exc:
raise error.CarrierError(exc)
return self
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
spinUntil(lambda:sp.started and cp.started)
cp.transport.write("hi")
spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back")
s.stopListening()
c.stopListening()
os.unlink(clientaddr)
os.unlink(serveraddr)
spinWhile(lambda:s.connected and c.connected)
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
def testExchange(self):
clientaddr = self.mktemp()
serveraddr = self.mktemp()
sp = ServerProto()
cp = ClientProto()
s = reactor.listenUNIXDatagram(serveraddr, sp)
c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr)
spinUntil(lambda:sp.started and cp.started)
cp.transport.write("hi")
spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back")
s.stopListening()
c.stopListening()
os.unlink(clientaddr)
os.unlink(serveraddr)
spinWhile(lambda:s.connected and c.connected)
self.failUnlessEqual("hi", sp.gotwhat)
self.failUnlessEqual(clientaddr, sp.gotfrom)
self.failUnlessEqual("hi back", cp.gotback)
def openClientMode(self, iface=''):
try:
self._lport = reactor.connectUNIXDatagram(iface, self)
except Exception:
raise error.CarrierError(sys.exc_info()[1])
return self
def openClientMode(self, iface=''):
try:
self._lport = reactor.connectUNIXDatagram(iface, self)
except Exception:
raise error.CarrierError(sys.exc_info()[1])
return self
def openClientMode(self, iface=''):
try:
self._lport = reactor.connectUNIXDatagram(iface, self)
except Exception, why:
raise error.CarrierError(why)