def auth(self, auth):
# Special case in XMPP: '=' means a zero-byte blob, whereas an empty
# or self-terminating XML element means no initial response.
# (RFC 3920 §6.2 (3))
if str(auth) == '':
self._event_func(
Event('sasl-auth',
authenticator=self,
has_initial_response=False,
initial_response=None,
xml=auth))
elif str(auth) == '=':
self._event_func(
Event('sasl-auth',
authenticator=self,
has_initial_response=False,
initial_response=None,
xml=auth))
else:
self._event_func(
Event('sasl-auth',
authenticator=self,
has_initial_response=True,
initial_response=b64decode(str(auth)),
xml=auth))
def signal_receiver(*args, **kw):
queue.append(
Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'],
args=map(unwrap, args),
interface=kw['interface']))
def secondIq(self, iq):
if self.emit_events:
self._event_func(
Event('auth-second-iq', authenticator=self, iq=iq,
id=iq["id"]))
else:
self.respondToSecondIq(iq)
def initialIq(self, iq):
if self.emit_events:
self._event_func(Event('auth-initial-iq', authenticator=self,
iq=iq, id=iq["id"]))
else:
self.respondToInitialIq(iq)
self.xmlstream.addOnetimeObserver('/iq/query/username', self.secondIq)
def exec_test_deferred(funs, params, protocol=None, timeout=None):
colourer = None
if sys.stdout.isatty():
colourer = install_colourer()
queue = servicetest.IteratingEventQueue(timeout)
queue.verbose = (os.environ.get('CHECK_TWISTED_VERBOSE', '') != ''
or '-v' in sys.argv)
bus = dbus.SessionBus()
sim = Simulator()
bus.add_signal_receiver(
lambda *args, **kw: queue.append(
Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'],
args=map(unwrap, args),
interface=kw['interface'])),
None, # signal name
None, # interface
None,
path_keyword='path',
member_keyword='member',
interface_keyword='interface',
byte_arrays=True)
try:
for f in funs:
conn = make_connection(bus, queue.append, params)
f(queue, bus, conn)
except Exception:
import traceback
traceback.print_exc()
try:
if colourer:
sys.stdout = colourer.fh
reactor.crash()
# force Disconnect in case the test crashed and didn't disconnect
# properly. We need to call this async because the BaseIRCServer
# class must do something in response to the Disconnect call and if we
# call it synchronously, we're blocking ourself from responding to the
# quit method.
servicetest.call_async(queue, conn, 'Disconnect')
if 'RING_TEST_REFDBG' in os.environ:
# we have to wait for the timeout so the process is properly
# exited and refdbg can generate its report
time.sleep(5.5)
except dbus.DBusException:
pass
def _service_removed_cb(self, interface, protocol, name, stype, domain,
flags):
e = Event('service-removed',
interface=interface,
protocol=protocol,
name=name,
stype=stype,
domain=domain,
flags=flags)
self.event_queue.append(e)
def signal_receiver(*args, **kw):
if kw['path'] == '/org/freedesktop/DBus' and \
kw['member'] == 'NameOwnerChanged':
bus_name, old_name, new_name = args
if new_name == '':
for i, conn in enumerate(conns):
stream = streams[i]
jid = jids[i]
if conn._requested_bus_name == bus_name:
factory.lost_presence(stream, jid)
break
queue.append(Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'], args=map(unwrap, args),
interface=kw['interface']))
def _service_found(self, interface, protocol, name, stype, domain,
host_name, aprotocol, pt, port, txt, flags):
e = Event('service-resolved',
service=self,
interface=interface,
protocol=protocol,
name=name,
stype=stype,
host_name=host_name,
aprotocol=aprotocol,
pt=pt,
port=port,
txt=txt,
flags=flags)
self.event_queue.append(e)
def _service_added_cb(self, interface, protocol, name, stype, domain,
flags):
service = AvahiService(self.event_queue, self.bus, self.server,
interface, protocol, name, stype, domain,
protocol, 0)
e = Event('service-added',
service=service,
interface=interface,
protocol=protocol,
name=name,
stype=stype,
domain=domain,
flags=flags)
self.event_queue.append(e)
def __init__(self, event_function, name=None, remote_name=None):
xmlstream.XmlStream.__init__(self)
self.name = name
self.remote_name = remote_name
self.event_func = event_function
self.event_function = event_function
self.addObserver(xmlstream.STREAM_START_EVENT,
lambda *args: self.event(Event('stream-opened')))
self.addObserver(
'//features',
lambda x: self.event(make_stream_event('stream-features', x)))
self.addObserver('//iq', lambda x: self.event(make_iq_event(x)))
self.addObserver('//message',
lambda x: self.event(make_message_event(x)))
self.addObserver('//presence',
lambda x: self.event(make_presence_event(x)))
def prepare_test(event_func, register_cb, params=None):
actual_params = {
'account': '[email protected]',
'password': '******',
'proxy-host': '127.0.0.1',
'port': dbus.UInt16(random.randint(9090, 9999)),
'local-ip-address': '127.0.0.1',
'transport': 'udp'
}
if params is not None:
for k, v in params.items():
if v is None:
actual_params.pop(k, None)
else:
actual_params[k] = v
bus = dbus.SessionBus()
conn = servicetest.make_connection(bus, event_func,
'sofiasip', 'sip', actual_params)
bus.add_signal_receiver(
lambda *args, **kw:
event_func(
Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'], args=map(unwrap, args),
interface=kw['interface'])),
None, # signal name
None, # interface
None,
path_keyword='path',
member_keyword='member',
interface_keyword='interface',
byte_arrays=True
)
port = int(actual_params['port'])
sip = SipProxy(host=actual_params['proxy-host'], port=port)
sip.event_func = event_func
sip.registrar_handler = register_cb
reactor.listenUDP(port, sip)
return bus, conn, sip
def exec_test_deferred (funs, params, protocol=None, timeout=None):
colourer = None
if sys.stdout.isatty():
colourer = install_colourer()
queue = servicetest.IteratingEventQueue(timeout)
queue.verbose = (
os.environ.get('CHECK_TWISTED_VERBOSE', '') != ''
or '-v' in sys.argv)
bus = dbus.SessionBus()
# conn = make_connection(bus, queue.append, params)
(server, port) = start_server(queue.append, protocol=protocol)
bus.add_signal_receiver(
lambda *args, **kw:
queue.append(
Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'], args=map(unwrap, args),
interface=kw['interface'])),
None, # signal name
None, # interface
None,
path_keyword='path',
member_keyword='member',
interface_keyword='interface',
byte_arrays=True
)
error = None
try:
for f in funs:
conn = make_connection(bus, queue.append, params)
f(queue, bus, conn, server)
except Exception, e:
import traceback
traceback.print_exc()
error = e
def my_method_cb(result):
q.append(Event('tube-dbus-return', method='MyMethod', value=[result]))
def _abort(self, abort):
self._event_func(Event('sasl-abort', authenticator=self,
xml=abort))
'server': 'localhost',
'port': dbus.UInt32(4343),
}
conn2, jid2 = make_connection(bus, queue.append, params)
authenticator = XmppAuthenticator('test2', 'pass')
stream2 = make_stream(queue.append, authenticator, protocol=XmppXmlStream)
factory = twisted.internet.protocol.Factory()
factory.protocol = lambda: stream2
port1 = reactor.listenTCP(4343, factory, interface='localhost')
bus.add_signal_receiver(
lambda *args, **kw: queue.append(
Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'],
args=map(unwrap, args),
interface=kw['interface'])),
None, # signal name
None, # interface
None,
path_keyword='path',
member_keyword='member',
interface_keyword='interface',
byte_arrays=True)
try:
test(queue, bus, conn1, conn2, stream1, stream2)
finally:
try:
conn1.Disconnect()
def process(self):
self.queue.append(Event('http-request',
method=self.method, path=self.path, request=self))
def _response(self, response):
self._event_func(Event('sasl-response', authenticator=self,
response=b64decode(str(response)),
xml=response))
def clientConnectionLost(self, connector, reason):
self.event_func(
Event('s5b-connection-lost', connector=connector, reason=reason))
def clientConnectionFailed(self, connector, reason):
self.event_func(Event('s5b-connection-failed', reason=reason))
def dataReceived(self, data):
self.factory.event_func(
Event('s5b-data-received', data=data, transport=self.transport))
def startedConnecting(self, connector):
self.event_func(Event('s5b-started-connecting', connector=connector))
'server': 'localhost',
'port': dbus.UInt32(4343),
}
conn2, jid2 = make_connection(bus, queue.append, params)
authenticator = XmppAuthenticator('test2', 'pass')
stream2 = make_stream(queue.append, authenticator, protocol=XmppXmlStream)
factory = twisted.internet.protocol.Factory()
factory.protocol = lambda: stream2
port1 = reactor.listenTCP(4343, factory, interface='localhost')
bus.add_signal_receiver(
lambda *args, **kw: queue.append(
Event('dbus-signal',
path=unwrap(kw['path']),
signal=kw['member'],
args=[unwrap(a) for a in args],
interface=kw['interface'])),
None, # signal name
None, # interface
None,
path_keyword='path',
member_keyword='member',
interface_keyword='interface',
byte_arrays=True)
try:
test(queue, bus, conn1, conn2, stream1, stream2)
finally:
try:
conn1.Disconnect()
def buildProtocol(self, addr):
p = self.protocol()
p.factory = self
e = Event('incoming-connection', listener=self)
p.event(e)
return p
def connected(self, stream):
e = Event('connection-result', succeeded=True)
self.event(e)
self.send_header()
def my_sig_cb(arg, sender=None):
assert tube2_names[contact1_handle_on_conn2] == sender
q.append(Event('tube-dbus-signal', signal='MySig', args=[arg]))
def clientConnectionFailed(self, connector, reason):
ClientFactory.clientConnectionFailed(self, connector, reason)
e = Event('connection-result', succeeded=False, reason=reason)
self.event_func(e)
def _all_for_now_cb(self):
self.event_queue.append(Event('service-all-for-now'))
def MyMethod(self, arg):
self.q.append(Event('tube-dbus-call', method='MyMethod', args=[arg]))
return arg * 10
def _service_failed(self, error):
e = Event('service-failed', service=self, error=error)
self.event_queue.append(e)
def connectionMade(self):
self.factory.event_func(
Event('s5b-connected', transport=self.transport))
