def send_dbus_message_to_alice(q, stream, dbus_tube_adr, bytestream):
tube = Connection(dbus_tube_adr)
signal = SignalMessage('/', 'foo.bar', 'baz')
signal.append(42, signature='u')
tube.send_message(signal)
binary = bytestream.get_data()
# little and big endian versions of: SIGNAL, NO_REPLY, protocol v1,
# 4-byte payload
assert binary.startswith('l\x04\x01\x01' '\x04\x00\x00\x00') or \
binary.startswith('B\x04\x01\x01' '\x00\x00\x00\x04')
# little and big endian versions of the 4-byte payload, UInt32(42)
assert (binary[0] == 'l' and binary.endswith('\x2a\x00\x00\x00')) or \
(binary[0] == 'B' and binary.endswith('\x00\x00\x00\x2a'))
# XXX: verify that it's actually in the "sender" slot, rather than just
# being in the message somewhere
watch_tube_signals(q, tube)
dbus_message = binary
# Have the fake client send us a message all in one go...
bytestream.send_data(dbus_message)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
# ... and a message one byte at a time ...
for byte in dbus_message:
bytestream.send_data(byte)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
# ... and two messages in one go
bytestream.send_data(dbus_message + dbus_message)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
def _load(self):
conn = Connection(
self._application_context.options.embed_plugin_address)
proxy = conn.get_object(None, self._dbus_object_path)
self._remote_container = Interface(
proxy, 'org.ros.qt_gui.PluginHandlerContainer')
self._remote_container.connect_to_signal('shutdown_plugin',
self._shutdown_plugin)
self._remote_container.connect_to_signal(
'save_settings', self._save_settings_from_remote)
self._remote_container.connect_to_signal(
'restore_settings', self._restore_settings_from_remote)
self._remote_container.connect_to_signal('trigger_configuration',
self._trigger_configuration)
self._remote_container.connect_to_signal(
'toolbar_orientation_changed', self._toolbar_orientation_changed)
proxy = conn.get_object(None, self._dbus_object_path + '/plugin')
self._remote_plugin_settings = Interface(proxy,
'org.ros.qt_gui.Settings')
proxy = conn.get_object(None, self._dbus_object_path + '/instance')
self._remote_instance_settings = Interface(proxy,
'org.ros.qt_gui.Settings')
super(PluginHandlerXEmbedClient, self)._load()
def send_dbus_message_to_alice(q, stream, dbus_tube_adr, bytestream):
tube = Connection(dbus_tube_adr)
signal = SignalMessage('/', 'foo.bar', 'baz')
signal.append(42, signature='u')
tube.send_message(signal)
binary = bytestream.get_data()
# little and big endian versions of: SIGNAL, NO_REPLY, protocol v1,
# 4-byte payload
assert binary.startswith('l\x04\x01\x01' '\x04\x00\x00\x00') or \
binary.startswith('B\x04\x01\x01' '\x00\x00\x00\x04')
# little and big endian versions of the 4-byte payload, UInt32(42)
assert (binary[0] == 'l' and binary.endswith('\x2a\x00\x00\x00')) or \
(binary[0] == 'B' and binary.endswith('\x00\x00\x00\x2a'))
# XXX: verify that it's actually in the "sender" slot, rather than just
# being in the message somewhere
watch_tube_signals(q, tube)
dbus_message = binary
# Have the fake client send us a message all in one go...
bytestream.send_data(dbus_message)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
# ... and a message one byte at a time ...
for byte in dbus_message:
bytestream.send_data(byte)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
# ... and two messages in one go
bytestream.send_data(dbus_message + dbus_message)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
q.expect('tube-signal', signal='baz', args=[42], tube=tube)
def _load(self):
conn = Connection(self._application_context.options.embed_plugin_address)
proxy = conn.get_object(None, self._dbus_object_path)
self._remote_container = Interface(proxy, 'org.ros.qt_gui.PluginHandlerContainer')
self._remote_container.connect_to_signal('shutdown_plugin', self._shutdown_plugin)
self._remote_container.connect_to_signal('save_settings', self._save_settings_from_remote)
self._remote_container.connect_to_signal('restore_settings', self._restore_settings_from_remote)
self._remote_container.connect_to_signal('trigger_configuration', self._trigger_configuration)
self._remote_container.connect_to_signal('toolbar_orientation_changed', self._toolbar_orientation_changed)
proxy = conn.get_object(None, self._dbus_object_path + '/plugin')
self._remote_plugin_settings = Interface(proxy, 'org.ros.qt_gui.Settings')
proxy = conn.get_object(None, self._dbus_object_path + '/instance')
self._remote_instance_settings = Interface(proxy, 'org.ros.qt_gui.Settings')
super(PluginHandlerXEmbedClient, self)._load()
tube_node['stream-id'] = dbus_stream_id
tube_node['dbus-name'] = bob_bus_name
stream.send(presence)
# Bob joins the tube
bob_in_tube()
dbus_changed_event = q.expect('dbus-signal',
signal='DBusNamesChanged',
interface=cs.CHANNEL_TYPE_DBUS_TUBE)
added, removed = dbus_changed_event.args
assert added == {bob_handle: bob_bus_name}
assert removed == []
tube = Connection(dbus_tube_adr)
fire_signal_on_tube(q, tube, '*****@*****.**', dbus_stream_id,
my_bus_name)
names = tube_chan.Get(cs.CHANNEL_TYPE_DBUS_TUBE,
'DBusNames',
dbus_interface=cs.PROPERTIES_IFACE)
assert names == {tube_self_handle: my_bus_name, bob_handle: bob_bus_name}
# Bob leave the tube
presence = elem('presence',
from_='[email protected]/bob',
to='*****@*****.**')(elem('x', xmlns=ns.MUC_USER),
elem('tubes', xmlns=ns.TUBES))
stream.send(presence)
def test(q, bus, conn, stream, access_control):
iq_event = q.expect('stream-iq',
to=None,
query_ns='vcard-temp',
query_name='vCard')
acknowledge_iq(stream, iq_event.stanza)
# check if we can request muc D-Bus tube
t.check_conn_properties(q, conn)
self_handle = conn.Properties.Get(cs.CONN, "SelfHandle")
self_name = conn.inspect_contact_sync(self_handle)
# offer a D-Bus tube to another room using new API
muc = '*****@*****.**'
request = {
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_DBUS_TUBE,
cs.TARGET_HANDLE_TYPE: cs.HT_ROOM,
cs.TARGET_ID: '*****@*****.**',
cs.DBUS_TUBE_SERVICE_NAME: 'com.example.TestCase',
}
join_muc(q, bus, conn, stream, muc, request=request)
exv = q.expect('dbus-signal', signal='NewChannels')
channels = exv.args[0]
assert len(channels) == 1
path, prop = channels[0]
assert prop[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_DBUS_TUBE
assert prop[cs.INITIATOR_ID] == '[email protected]/test'
assert prop[cs.REQUESTED] == True
assert prop[cs.TARGET_HANDLE_TYPE] == cs.HT_ROOM
assert prop[cs.TARGET_ID] == '*****@*****.**'
assert prop[cs.DBUS_TUBE_SERVICE_NAME] == 'com.example.TestCase'
assert prop[cs.DBUS_TUBE_SUPPORTED_ACCESS_CONTROLS] == [
cs.SOCKET_ACCESS_CONTROL_CREDENTIALS,
cs.SOCKET_ACCESS_CONTROL_LOCALHOST
]
# check that the tube channel is in the channels list
all_channels = conn.Get(cs.CONN_IFACE_REQUESTS,
'Channels',
dbus_interface=cs.PROPERTIES_IFACE,
byte_arrays=True)
assertContains((path, prop), all_channels)
tube_chan = wrap_channel(bus.get_object(conn.bus_name, path), 'DBusTube')
tube_props = tube_chan.Properties.GetAll(cs.CHANNEL_IFACE_TUBE,
byte_arrays=True)
assert tube_props['State'] == cs.TUBE_CHANNEL_STATE_NOT_OFFERED
# try to offer using a wrong access control
try:
tube_chan.DBusTube.Offer(sample_parameters,
cs.SOCKET_ACCESS_CONTROL_PORT)
except dbus.DBusException as e:
assertEquals(e.get_dbus_name(), cs.INVALID_ARGUMENT)
else:
assert False
# offer the tube
call_async(q, tube_chan.DBusTube, 'Offer', sample_parameters,
access_control)
presence_event, return_event, status_event, dbus_changed_event = q.expect_many(
EventPattern('stream-presence',
to='[email protected]/test',
predicate=lambda e: t.presence_contains_tube(e)),
EventPattern('dbus-return', method='Offer'),
EventPattern('dbus-signal',
signal='TubeChannelStateChanged',
args=[cs.TUBE_CHANNEL_STATE_OPEN]),
EventPattern('dbus-signal',
signal='DBusNamesChanged',
interface=cs.CHANNEL_TYPE_DBUS_TUBE))
tube_self_handle = tube_chan.Properties.Get(cs.CHANNEL_IFACE_GROUP,
'SelfHandle')
assert tube_self_handle != 0
# handle presence_event
# We announce our newly created tube in our muc presence
presence = presence_event.stanza
dbus_stream_id, my_bus_name, dbus_tube_id = check_tube_in_presence(
presence, '[email protected]/test')
# handle dbus_changed_event
added, removed = dbus_changed_event.args
assert added == {tube_self_handle: my_bus_name}
assert removed == []
dbus_tube_adr = return_event.value[0]
bob_bus_name = ':2.Ym9i'
bob_handle = conn.get_contact_handle_sync('[email protected]/bob')
def bob_in_tube():
presence = elem('presence',
from_='[email protected]/bob',
to='*****@*****.**')(
elem('x', xmlns=ns.MUC_USER),
elem('tubes', xmlns=ns.TUBES)(
elem('tube',
type='dbus',
initiator='[email protected]/test',
service='com.example.TestCase',
id=str(dbus_tube_id))(elem('parameters')(
elem('parameter',
name='ay',
type='bytes')(u'aGVsbG8='),
elem('parameter',
name='s',
type='str')(u'hello'),
elem('parameter',
name='i',
type='int')(u'-123'),
elem('parameter',
name='u',
type='uint')(u'123')))))
# have to add stream-id and dbus-name attributes manually as we can't use
# keyword with '-'...
tube_node = xpath.queryForNodes('/presence/tubes/tube', presence)[0]
tube_node['stream-id'] = dbus_stream_id
tube_node['dbus-name'] = bob_bus_name
stream.send(presence)
# Bob joins the tube
bob_in_tube()
dbus_changed_event = q.expect('dbus-signal',
signal='DBusNamesChanged',
interface=cs.CHANNEL_TYPE_DBUS_TUBE)
added, removed = dbus_changed_event.args
assert added == {bob_handle: bob_bus_name}
assert removed == []
tube = Connection(dbus_tube_adr)
fire_signal_on_tube(q, tube, '*****@*****.**', dbus_stream_id,
my_bus_name)
names = tube_chan.Get(cs.CHANNEL_TYPE_DBUS_TUBE,
'DBusNames',
dbus_interface=cs.PROPERTIES_IFACE)
assert names == {tube_self_handle: my_bus_name, bob_handle: bob_bus_name}
# Bob leave the tube
presence = elem('presence',
from_='[email protected]/bob',
to='*****@*****.**')(elem('x', xmlns=ns.MUC_USER),
elem('tubes', xmlns=ns.TUBES))
stream.send(presence)
dbus_changed_event = q.expect('dbus-signal',
signal='DBusNamesChanged',
interface=cs.CHANNEL_TYPE_DBUS_TUBE)
added, removed = dbus_changed_event.args
assert added == {}
assert removed == [bob_handle]
names = tube_chan.Get(cs.CHANNEL_TYPE_DBUS_TUBE,
'DBusNames',
dbus_interface=cs.PROPERTIES_IFACE)
assert names == {tube_self_handle: my_bus_name}
tube_chan.Channel.Close()
_, _, event = q.expect_many(
EventPattern('dbus-signal', signal='Closed'),
EventPattern('dbus-signal', signal='ChannelClosed'),
EventPattern('stream-presence',
to='[email protected]/test',
presence_type='unavailable'))
# we must echo the MUC presence so the room will actually close
# and we should wait to make sure gabble has actually parsed our
# echo before trying to rejoin
echo_muc_presence(q, stream, event.stanza, 'none', 'participant')
sync_stream(q, stream)
# rejoin the room
call_async(
q, conn.Requests, 'CreateChannel', {
cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_TEXT,
cs.TARGET_HANDLE_TYPE: cs.HT_ROOM,
cs.TARGET_ID: '*****@*****.**'
})
q.expect('stream-presence', to='[email protected]/test')
# Bob is in the room and in the tube
bob_in_tube()
# Send presence for own membership of room.
stream.send(make_muc_presence('none', 'participant', muc, 'test'))
def new_tube(e):
path, props = e.args[0][0]
return props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_DBUS_TUBE
def new_text(e):
path, props = e.args[0][0]
return props[cs.CHANNEL_TYPE] == cs.CHANNEL_TYPE_TEXT
# tube and text is created
text_event, tube_event = q.expect_many(
EventPattern('dbus-signal', signal='NewChannels', predicate=new_text),
EventPattern('dbus-signal', signal='NewChannels', predicate=new_tube))
channels = exv.args[0]
tube_path, props = tube_event.args[0][0]
assertEquals(cs.CHANNEL_TYPE_DBUS_TUBE, props[cs.CHANNEL_TYPE])
assertEquals('[email protected]/test', props[cs.INITIATOR_ID])
assertEquals(False, props[cs.REQUESTED])
assertEquals(cs.HT_ROOM, props[cs.TARGET_HANDLE_TYPE])
assertEquals('com.example.TestCase', props[cs.DBUS_TUBE_SERVICE_NAME])
_, props = text_event.args[0][0]
assertEquals(cs.CHANNEL_TYPE_TEXT, props[cs.CHANNEL_TYPE])
assertEquals(True, props[cs.REQUESTED])
# tube is local-pending
tube_chan = bus.get_object(conn.bus_name, tube_path)
state = tube_chan.Get(cs.CHANNEL_IFACE_TUBE,
'State',
dbus_interface=dbus.PROPERTIES_IFACE)
assertEquals(cs.TUBE_STATE_LOCAL_PENDING, state)
