def test_take_ownership(self):
if not self._can_create:
self.skipTest('Cannot create %s filesystem' % self._fs_name)
if not self._can_mount:
self.skipTest('Cannot mount %s filesystem' % self._fs_name)
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
self.assertIsNotNone(disk)
# create filesystem
disk.Format(self._fs_name,
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
self.addCleanup(self._clean_format, self.vdevs[0])
# create user for our test
self.addCleanup(self._remove_user, self.username)
uid, gid = self._add_user(self.username)
# mount the device
mnt_path = disk.Mount(self.no_options,
dbus_interface=self.iface_prefix + '.Filesystem')
self.addCleanup(self._unmount, self.vdevs[0])
# change owner of the mountpoint to our user
os.chown(mnt_path, int(uid), int(gid))
# now take ownership of the filesystem -- owner should now be root
disk.TakeOwnership(self.no_options,
dbus_interface=self.iface_prefix + '.Filesystem')
sys_stat = os.stat(mnt_path)
self.assertEqual(sys_stat.st_uid, 0)
self.assertEqual(sys_stat.st_gid, 0)
# change the owner back and create some files and directories there
os.chown(mnt_path, int(uid), int(gid))
dirname = 'udisks_test_dir'
fname = 'file.txt'
os.mknod(os.path.join(mnt_path, fname))
os.mkdir(os.path.join(mnt_path, dirname))
os.mknod(os.path.join(mnt_path, dirname, fname))
# now take ownership of the filesystem with recursive option -- owner
# of everything should now be root
d = dbus.Dictionary(signature='sv')
d['recursive'] = True
disk.TakeOwnership(d, dbus_interface=self.iface_prefix + '.Filesystem')
sys_stat = os.stat(mnt_path)
self.assertEqual(sys_stat.st_uid, 0)
self.assertEqual(sys_stat.st_gid, 0)
sys_stat = os.stat(os.path.join(mnt_path, dirname))
self.assertEqual(sys_stat.st_uid, 0)
self.assertEqual(sys_stat.st_gid, 0)
sys_stat = os.stat(os.path.join(mnt_path, dirname, fname))
self.assertEqual(sys_stat.st_uid, 0)
self.assertEqual(sys_stat.st_gid, 0)
def test_configuration_crypttab(self):
# this test will change /etc/crypttab, we might want to revert the changes when it finishes
crypttab = self.read_file('/etc/crypttab')
self.addCleanup(self.write_file, '/etc/crypttab', crypttab)
# format the disk
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
disk.Format('xfs', {'encrypt.passphrase': 'test'},
dbus_interface=self.iface_prefix + '.Block')
# cleanup -- close the luks and remove format
self.addCleanup(self._clean_format, disk)
self.addCleanup(self._close_luks, disk)
# configuration items as arrays of dbus.Byte
opts = self.str_to_ay('verify')
passwd = self.str_to_ay('test')
# set the new configuration
conf = dbus.Dictionary({
'passphrase-contents': passwd,
'options': opts
},
signature=dbus.Signature('sv'))
disk.AddConfigurationItem(('crypttab', conf),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# get the configuration
old_conf = self.get_property(disk, '.Block', 'Configuration')
old_conf.assertTrue()
self.assertEqual(old_conf.value[0][1]['options'], opts)
# get the secret configuration (passphrase)
sec_conf = disk.GetSecretConfiguration(
self.no_options, dbus_interface=self.iface_prefix + '.Block')
self.assertIsNotNone(sec_conf)
self.assertEqual(sec_conf[0][1]['passphrase-contents'], passwd)
# update the configuration
new_opts = self.str_to_ay('verify,discard')
new_conf = copy.deepcopy(sec_conf)
new_conf[0][1]['options'] = new_opts
disk.UpdateConfigurationItem(
(sec_conf[0][0], sec_conf[0][1]), (new_conf[0][0], new_conf[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
time.sleep(5)
# get the configuration after the update
upd_conf = self.get_property(disk, '.Block', 'Configuration')
upd_conf.assertTrue()
self.assertEqual(upd_conf.value[0][1]['options'], new_opts)
# remove the configuration
disk.RemoveConfigurationItem(
(upd_conf.value[0][0], upd_conf.value[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
upd_conf = self.get_property(disk, '.Block', 'Configuration')
upd_conf.assertFalse()
def getResourcesProducedHistory(self, node_id: str) -> Dict:
history = self._node_engine.getNodeHistoryById(node_id)
if history:
return dbus.Dictionary(history.getResourcesProducedHistory(),
signature='sv')
return {}
def add_manufacturer_data(self, manuf_code, data):
if not self.manufacturer_data:
self.manufacturer_data = dbus.Dictionary({}, signature="qv")
self.manufacturer_data[manuf_code] = dbus.Array(data, signature="y")
def _clean_format(self, disk):
d = dbus.Dictionary(signature='sv')
d['erase'] = True
disk.Format('empty', d, dbus_interface=self.iface_prefix + '.Block')
def modify_connection(params, nm=NetworkManager()):
types = {
'wired': '802-3-ethernet',
'wireless': '802-11-wireless',
'cdma': 'cdma',
}
type2desc = {1: '802-3-ethernet', 2: '802-11-wireless'}
#uuid = params['nm.uuid']
#conn = None
#if uuid != "":
# conn = nm.get_connection(uuid)
#if conn == None:
conn_list = []
for conn in nm.connections:
for interface in nm.devices:
if str(conn.settings.mac_address) == str(interface.hwaddress):
dev_state = interface.proxy.Get(NM_DEVICE, "State")
dev_type_int = interface.proxy.Get(NM_DEVICE, "DeviceType")
dev_type = type2desc.get(dev_type_int, None)
conn_list.append((conn, dev_type, int(dev_state)))
break
try:
xbmc.log("conn_list: " + str(conn_list))
except:
syslog.syslog("conn_list: " + str(conn_list))
active_conn_list = []
for a in conn_list:
if a[2] >= 20: # http://projects.gnome.org/NetworkManager/developers/api/09/spec.html#type-NM_DEVICE_STATE
# any states other than NM_DEVICE_STATE_UNKNOWN
# NM_DEVICE_STATE_UNMANAGED
active_conn_list.append(a)
#for b in active_conn_list:
# conn = b[0]
# if b[1] == type2desc[1]: # Wired Network
# break
#if conn == None:
# for c in conn_list:
# conn = c[0]
# if c[1] == type2desc[1]: # Wired Networ
# break
RETURN_CODE = -11
if len(active_conn_list) > 0:
for a in active_conn_list:
conn = a[0]
settings = conn.settings
old_settings = str(settings._settings)
if a[1] == type2desc[1]: # Wired Network
if params['nm.dhcp'] == "false":
address = params['nm.address']
netmask = params['nm.netmask']
gateway = params['nm.gateway']
dns = params['nm.dns']
dns_search = params['nm.search']
if a[1] == type2desc[2]: # Wireless Network
if params['nm.wifi.dhcp'] == "false":
address = params['nm.wifi.address']
netmask = params['nm.wifi.netmask']
gateway = params['nm.wifi.gateway']
dns = params['nm.wifi.dns']
dns_search = params['nm.wifi.search']
# 802-11-wireless
if params["nm.wifi.5GOnly"] == "true":
# 5GHz 802.11a
band = "a"
else:
# 2.4GHz 802.11
band = "bg"
## WiFi network mode
if params["nm.wifi.adhoc"] == "true":
mode = "adhoc"
else:
mode = "infrastructure"
security = "802-11-wireless-security"
key_mgmt = "none"
# None
if params["nm.wifi.security"] == "0":
security = ""
# WEP (Open Key)
if params["nm.wifi.security"] == "1":
key_mgmt = "none"
auth_alg = "open"
# WEP (Shared Key)
if params["nm.wifi.security"] == "2":
key_mgmt = "none"
auth_alg = "shared"
# Dynamic WEP
if params["nm.wifi.security"] == "3":
key_mgmt = "ieee8021x"
# WPA/WPA2
if params["nm.wifi.security"] == "4":
if mode == "adhoc":
key_mgmt = "wpa-none"
else:
key_mgmt = "wpa-psk"
if "802-11-wireless" in settings._settings:
try:
xbmc.log(a[1] + " 802-11-wireless old: " +
str(settings._settings['802-11-wireless']))
except:
syslog.syslog(
a[1] + " 802-11-wireless old: " +
str(settings._settings['802-11-wireless']))
else:
settings._settings['802-11-wireless'] = dbus.Dictionary(
signature='sv')
# clear 802-11-wireless settings
# settings._settings['802-11-wireless'] = dbus.Dictionary(signature='sv')
settings._settings['802-11-wireless'][
'security'] = dbus.String(security)
settings._settings['802-11-wireless']['mode'] = dbus.String(
mode)
settings._settings['802-11-wireless']['band'] = dbus.String(
band)
SSID = []
for c in params["nm.wifi.ssid"]:
SSID.append(dbus.Byte(int(ord(c))))
settings._settings['802-11-wireless']['ssid'] = dbus.Array(
SSID, signature='y')
if "802-11-wireless-security" in settings._settings:
try:
xbmc.log(a[1] + " 802-11-wireless-security old: " +
str(settings.
_settings['802-11-wireless-security']))
except:
syslog.syslog(
a[1] + " 802-11-wireless-security old: " +
str(settings._settings['802-11-wireless-security'])
)
else:
if key_mgmt != "":
settings._settings[
'802-11-wireless-security'] = dbus.Dictionary(
signature='sv')
# clear 802-11-wireless-security settings
# settings._settings['802-11-wireless-security'] = dbus.Dictionary(signature='sv')
if key_mgmt == "" and "802-11-wireless-security" in settings._settings:
del (settings._settings['802-11-wireless-security'])
CONFIG_DIFFERENCE = True
if key_mgmt != "":
settings._settings['802-11-wireless-security'][
'security'] = dbus.String(security)
settings._settings['802-11-wireless-security'][
'key-mgmt'] = dbus.String(key_mgmt)
if key_mgmt == "none":
settings._settings['802-11-wireless-security'][
'auth-alg'] = dbus.String(auth_alg)
if len(params["nm.wifi.key"]) > 0:
settings._settings['802-11-wireless-security'][
'wep-key0'] = dbus.String(params["nm.wifi.key"])
settings._settings['802-11-wireless-security'][
'wep-key1'] = dbus.String(params["nm.wifi.key"])
else:
if len(params["nm.wifi.key"]) > 0:
settings._settings['802-11-wireless-security'][
'psk'] = dbus.String(params["nm.wifi.key"])
if not "ipv6" in settings._settings:
settings._settings['ipv6'] = dbus.Dictionary(signature='sv')
settings._settings['ipv6']['method'] = dbus.String("ignore")
if "ipv4" in settings._settings:
try:
xbmc.log(a[1] + " ipv4 old: " +
str(settings._settings['ipv4']))
except:
syslog.syslog(a[1] + " ipv4 old: " +
str(settings._settings['ipv4']))
else:
settings._settings['ipv4'] = dbus.Dictionary(signature='sv')
DHCP = False
if a[1] == type2desc[1] and params['nm.dhcp'] == "true":
DHCP = True
if a[1] == type2desc[2] and params['nm.wifi.dhcp'] == "true":
DHCP = True
if DHCP:
settings.set_auto()
if params['nm.uid.enable'] == "true":
mac_list = settings.mac_address.split(":")
uid = "xbmc-" + mac_list[4].lower() + mac_list[5].lower()
else:
uid = "xbmc"
settings._settings['ipv4']['dhcp-client-id'] = dbus.String(uid)
settings._settings['ipv4']['dhcp-hostname'] = dbus.String(uid)
settings._settings['ipv4'][
'dhcp-send-hostname'] = dbus.Boolean(1)
else:
if not 'addresses' in settings._settings['ipv4']:
settings._settings['ipv4']['addresses'] = dbus.Array(
[], signature='au')
settings.address = address
settings.netmask = netmask
settings.gateway = gateway
settings.dns = dns
settings._settings['ipv4']['dns-search'] = dbus.Array(
[dns_search], signature='s')
#conn.proxy.Update(settings._settings, dbus_interface=NM_SETTINGS_CONNECTION)
if old_settings != str(settings._settings):
try:
xbmc.log(str(settings.type))
if "ipv4" in settings._settings:
xbmc.log(a[1] + "ipv4 new: " +
str(settings._settings['ipv4']))
if "802-11-wireless" in settings._settings:
xbmc.log(a[1] + "802-11-wireless: " +
str(settings._settings['802-11-wireless']))
if "802-11-wireless-security" in settings._settings:
xbmc.log(a[1] + "802-11-wireless-security: " + str(
settings._settings['802-11-wireless-security']))
except:
syslog.syslog(str(settings.type))
if "ipv4" in settings._settings:
syslog.syslog(a[1] + "ipv4 new: " +
str(settings._settings['ipv4']))
if "802-11-wireless" in settings._settings:
syslog.syslog(
a[1] + "802-11-wireless new: " +
str(settings._settings['802-11-wireless']))
if "802-11-wireless-security" in settings._settings:
syslog.syslog(
a[1] + "802-11-wireless-security new: " +
str(settings._settings['802-11-wireless-security'])
)
conn.update(settings)
# return 10 if settings need to update
RETURN_CODE = 10
else:
# return 0 if settings do not need to update
RETURN_CODE = 0
return RETURN_CODE
def test_login_mutual_auth(self):
self._set_initiator_name(
) # set initiator name to the one set in targetcli config
manager = self.get_object('/Manager')
nodes, _ = manager.DiscoverSendTargets(
self.address,
self.port,
self.no_options,
dbus_interface=self.iface_prefix + '.Manager.ISCSI.Initiator')
node = next((node for node in nodes if node[0] == self.mutual_iqn),
None)
self.assertIsNotNone(node)
(iqn, tpg, host, port, iface) = node
self.assertEqual(iqn, self.mutual_iqn)
self.assertEqual(host, self.address)
self.assertEqual(port, self.port)
options = dbus.Dictionary(signature='sv')
options['username'] = self.initiator
options['password'] = self.password
options['reverse-username'] = self.mutual_iqn
options['reverse-password'] = self.mutual_password
self.addCleanup(self._force_lougout, self.mutual_iqn)
manager.Login(iqn,
tpg,
host,
port,
iface,
options,
dbus_interface=self.iface_prefix +
'.Manager.ISCSI.Initiator')
devs = glob.glob('/dev/disk/by-path/*%s*' % iqn)
self.assertEqual(len(devs), 1)
# check if the block device have 'Symlinks' property updated
disk_name = os.path.realpath(devs[0]).split('/')[-1]
disk_obj = self.get_object('/block_devices/' + disk_name)
dbus_path = str(disk_obj.object_path)
self.assertIsNotNone(disk_obj)
symlinks = self.get_property_raw(disk_obj, '.Block', 'Symlinks')
self.assertIn(self.str_to_ay(devs[0]), symlinks)
manager.Logout(iqn,
tpg,
host,
port,
iface,
self.no_options,
dbus_interface=self.iface_prefix +
'.Manager.ISCSI.Initiator')
devs = glob.glob('/dev/disk/by-path/*%s*' % iqn)
self.assertEqual(len(devs), 0)
# make sure the disk is no longer on dbus
udisks = self.get_object('')
objects = udisks.GetManagedObjects(
dbus_interface='org.freedesktop.DBus.ObjectManager')
self.assertNotIn(dbus_path, objects.keys())
def test_open(self):
# O_ACCMODE is node defined in Python 2 version of 'os' module
try:
from os import O_ACCMODE
except ImportError:
O_ACCMODE = 3
# format the disk
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
disk.Format('xfs',
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
self.addCleanup(self.wipe_fs, self.vdevs[0])
# OpenForBackup
dbus_fd = disk.OpenForBackup(self.no_options,
dbus_interface=self.iface_prefix +
'.Block')
self.assertIsNotNone(dbus_fd)
fd = dbus_fd.take()
mode = fcntl.fcntl(fd, fcntl.F_GETFL) & O_ACCMODE
self.assertEqual(mode, os.O_RDONLY)
os.close(fd)
# OpenForRestore
dbus_fd = disk.OpenForRestore(self.no_options,
dbus_interface=self.iface_prefix +
'.Block')
self.assertIsNotNone(dbus_fd)
fd = dbus_fd.take()
mode = fcntl.fcntl(fd, fcntl.F_GETFL) & O_ACCMODE
self.assertEqual(mode, os.O_WRONLY)
os.close(fd)
# OpenForBenchmark
dbus_fd = disk.OpenForBenchmark(self.no_options,
dbus_interface=self.iface_prefix +
'.Block')
self.assertIsNotNone(dbus_fd)
fd = dbus_fd.take()
mode = fcntl.fcntl(fd, fcntl.F_GETFL)
self.assertTrue(bool(mode & os.O_DIRECT))
self.assertTrue(bool(mode & os.O_SYNC))
os.close(fd)
# OpenDevice
with self.assertRaises(dbus.exceptions.DBusException): # invalid mode
disk.OpenDevice('abc',
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
d = dbus.Dictionary(signature='sv')
d['flags'] = os.O_RDWR
with self.assertRaises(dbus.exceptions.DBusException
): # read-only mode with O_RDWR flag
disk.OpenDevice('r',
d,
dbus_interface=self.iface_prefix + '.Block')
d = dbus.Dictionary(signature='sv')
d['flags'] = os.O_ASYNC | os.O_DIRECT
dbus_fd = disk.OpenDevice('w',
d,
dbus_interface=self.iface_prefix + '.Block')
self.assertIsNotNone(dbus_fd)
fd = dbus_fd.take()
mode = fcntl.fcntl(fd, fcntl.F_GETFL)
self.assertTrue(bool(mode & os.O_WRONLY))
self.assertTrue(bool(mode & os.O_DIRECT))
self.assertTrue(bool(mode & os.O_ASYNC))
os.close(fd)
def test_format(self):
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
self.assertIsNotNone(disk)
# this might fail in case of stray udev rules or records in /etc/fstab
hint_auto = self.get_property_raw(disk, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(False))
hint_ignore = self.get_property_raw(disk, '.Block', 'HintIgnore')
self.assertEqual(hint_ignore, dbus.Boolean(False))
hint_partitionable = self.get_property_raw(disk, '.Block',
'HintPartitionable')
self.assertEqual(hint_partitionable, dbus.Boolean(True))
hint_system = self.get_property_raw(disk, '.Block', 'HintSystem')
self.assertEqual(hint_system, dbus.Boolean(True))
# create xfs filesystem
disk.Format('xfs',
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
usage = self.get_property(disk, '.Block', 'IdUsage')
usage.assertEqual('filesystem')
fstype = self.get_property(disk, '.Block', 'IdType')
fstype.assertEqual('xfs')
hint_auto = self.get_property_raw(disk, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(False))
hint_ignore = self.get_property_raw(disk, '.Block', 'HintIgnore')
self.assertEqual(hint_ignore, dbus.Boolean(False))
hint_partitionable = self.get_property_raw(disk, '.Block',
'HintPartitionable')
self.assertEqual(hint_partitionable, dbus.Boolean(True))
hint_system = self.get_property_raw(disk, '.Block', 'HintSystem')
self.assertEqual(hint_system, dbus.Boolean(True))
_ret, sys_fstype = self.run_command('lsblk -d -no FSTYPE %s' %
self.vdevs[0])
self.assertEqual(sys_fstype, 'xfs')
# remove the format
d = dbus.Dictionary(signature='sv')
d['erase'] = True
disk.Format('empty', d, dbus_interface=self.iface_prefix + '.Block')
# check if the disk is empty
usage = self.get_property(disk, '.Block', 'IdUsage')
usage.assertEqual('')
fstype = self.get_property(disk, '.Block', 'IdType')
fstype.assertEqual('')
hint_auto = self.get_property_raw(disk, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(False))
hint_ignore = self.get_property_raw(disk, '.Block', 'HintIgnore')
self.assertEqual(hint_ignore, dbus.Boolean(False))
hint_partitionable = self.get_property_raw(disk, '.Block',
'HintPartitionable')
self.assertEqual(hint_partitionable, dbus.Boolean(True))
hint_system = self.get_property_raw(disk, '.Block', 'HintSystem')
self.assertEqual(hint_system, dbus.Boolean(True))
_ret, sys_fstype = self.run_command('lsblk -d -no FSTYPE %s' %
self.vdevs[0])
self.assertEqual(sys_fstype, '')
def reply(data):
dbus_async_cb(
dbus.Dictionary(data, signature='sv', variant_level=4))
def GetFacts(self, sender=None):
collection = self.facts_collector.collect()
cleaned = dict([(str(key), str(value))
for key, value in list(collection.data.items())])
return dbus.Dictionary(cleaned, signature="ss")
def __add_connection(self, ssid):
debug("Adding connection: " + ssid)
server_alt_subject_name_list = dbus.Array(Config.servers)
server_name = Config.server_match
if self.nm_version == "0.9" or self.nm_version == "1.0":
match_key = 'altsubject-matches'
match_value = server_alt_subject_name_list
else:
match_key = 'subject-match'
match_value = server_name
s_8021x_data = {
'eap': [Config.eap_outer.lower()],
'identity':
self.user_data.username,
'ca-cert':
dbus.ByteArray("file://{0}\0".format(
self.cacert_file).encode('utf8')),
match_key:
match_value
}
if Config.eap_outer == 'PEAP' or Config.eap_outer == 'TTLS':
s_8021x_data['password'] = self.user_data.password
s_8021x_data['phase2-auth'] = Config.eap_inner.lower()
if Config.anonymous_identity != '':
s_8021x_data['anonymous-identity'] = Config.anonymous_identity
s_8021x_data['password-flags'] = 0
if Config.eap_outer == 'TLS':
s_8021x_data['client-cert'] = dbus.ByteArray("file://{0}\0".format(
self.pfx_file).encode('utf8'))
s_8021x_data['private-key'] = dbus.ByteArray("file://{0}\0".format(
self.pfx_file).encode('utf8'))
s_8021x_data['private-key-password'] = self.user_data.password
s_8021x_data['private-key-password-flags'] = 0
s_con = dbus.Dictionary({
'type':
'802-11-wireless',
'uuid':
str(uuid.uuid4()),
'permissions': ['user:'******'USER')],
'id':
ssid
})
s_wifi = dbus.Dictionary({
'ssid': dbus.ByteArray(ssid.encode('utf8')),
'security': '802-11-wireless-security'
})
s_wsec = dbus.Dictionary({
'key-mgmt': 'wpa-eap',
'proto': ['rsn'],
'pairwise': ['ccmp'],
'group': ['ccmp', 'tkip']
})
s_8021x = dbus.Dictionary(s_8021x_data)
s_ip4 = dbus.Dictionary({'method': 'auto'})
s_ip6 = dbus.Dictionary({'method': 'auto'})
con = dbus.Dictionary({
'connection': s_con,
'802-11-wireless': s_wifi,
'802-11-wireless-security': s_wsec,
'802-1x': s_8021x,
'ipv4': s_ip4,
'ipv6': s_ip6
})
self.settings.AddConnection(con)
def test(q, bus, mc):
params = dbus.Dictionary({"account": "*****@*****.**",
"password": "******"}, signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
}, signature='sv')
vague_fixed_properties = dbus.Dictionary({
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
}, signature='sv')
empathy_bus = dbus.bus.BusConnection()
q.attach_to_bus(empathy_bus)
empathy = SimulatedClient(q, empathy_bus, 'Empathy',
observe=[text_fixed_properties], approve=[text_fixed_properties],
handle=[text_fixed_properties], bypass_approval=False)
# Kopete's filter is less specific than Empathy's, so we'll prefer Empathy
kopete_bus = dbus.bus.BusConnection()
q.attach_to_bus(kopete_bus)
kopete = SimulatedClient(q, kopete_bus, 'Kopete',
observe=[], approve=[],
handle=[vague_fixed_properties], bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [empathy, kopete])
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
channel_properties = dbus.Dictionary(text_fixed_properties,
signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
# A channel dispatch operation is created
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
# In this test Empathy's filter has more things in it than Kopete's, so
# MC will prefer Empathy
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
assert handlers == [cs.tp_name_prefix + '.Client.Empathy',
cs.tp_name_prefix + '.Client.Kopete'], handlers
assert cs.CD_IFACE_OP_LIST in cd_props.Get(cs.CD, 'Interfaces')
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') ==\
[(cdo_path, cdo_properties)]
cdo = bus.get_object(cs.CD, cdo_path)
cdo_iface = dbus.Interface(cdo, cs.CDO)
cdo_props_iface = dbus.Interface(cdo, cs.PROPERTIES_IFACE)
assert cdo_props_iface.Get(cs.CDO, 'Interfaces') == \
cdo_properties[cs.CDO + '.Interfaces']
assert cdo_props_iface.Get(cs.CDO, 'Connection') == conn.object_path
assert cdo_props_iface.Get(cs.CDO, 'Account') == account.object_path
assert cdo_props_iface.Get(cs.CDO, 'Channels') == [(chan.object_path,
channel_properties)]
assert cdo_props_iface.Get(cs.CDO, 'PossibleHandlers') == \
cdo_properties[cs.CDO + '.PossibleHandlers']
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.OBSERVER, method='ObserveChannels',
handled=False)
assert e.args[0] == account.object_path, e.args
assert e.args[1] == conn.object_path, e.args
assert e.args[3] == cdo_path, e.args
assert e.args[4] == [], e.args # no requests satisfied
channels = e.args[2]
assert len(channels) == 1, channels
assert channels[0][0] == chan.object_path, channels
assert channels[0][1] == channel_properties, channels
q.dbus_return(e.message, bus=empathy_bus, signature='')
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.APPROVER, method='AddDispatchOperation',
handled=False)
assert e.args == [[(chan.object_path, channel_properties)],
cdo_path, cdo_properties]
q.dbus_return(e.message, bus=empathy_bus, signature='')
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Empathy')
# Empathy is asked to handle the channels
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Empathy rejects the channels
q.dbus_raise(e.message, cs.NOT_AVAILABLE, 'Blind drunk', bus=empathy_bus)
e = q.expect('dbus-error', method='HandleWith')
assert e.error.get_dbus_name() == cs.NOT_AVAILABLE
assert e.error.get_dbus_message() == 'Blind drunk'
# The channels no longer count as having been approved. Check that MC
# doesn't carry on regardless
forbidden = [EventPattern('dbus-method-call', method='HandleChannels')]
q.forbid_events(forbidden)
sync_dbus(bus, q, mc)
q.unforbid_events(forbidden)
# I'm Feeling Lucky. It might work if I try again? Maybe?
call_async(q, cdo_iface, 'HandleWith',
cs.tp_name_prefix + '.Client.Empathy')
# Empathy is asked to handle the channels, again
e = q.expect('dbus-method-call',
path=empathy.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Empathy rejects the channels, again
q.dbus_raise(e.message, cs.NOT_CAPABLE, 'Still drunk', bus=empathy_bus)
e = q.expect('dbus-error', method='HandleWith')
assert e.error.get_dbus_name() == cs.NOT_CAPABLE
assert e.error.get_dbus_message() == 'Still drunk'
# OK, OK, is anyone else competent enough to handle them?
# (Also, assert that MC doesn't offer them back to Empathy, knowing that
# it already tried and failed)
forbidden = [EventPattern('dbus-method-call', method='HandleChannels',
path=empathy.object_path)]
q.forbid_events(forbidden)
call_async(q, cdo_iface, 'HandleWith', '')
# Kopete is asked to handle the channels
k = q.expect('dbus-method-call',
path=kopete.object_path,
interface=cs.HANDLER, method='HandleChannels',
handled=False)
# Kopete rejects the channels too
q.dbus_raise(k.message, cs.NOT_AVAILABLE, 'Also blind drunk',
bus=kopete_bus)
e = q.expect('dbus-error', method='HandleWith')
assert e.error.get_dbus_name() == cs.NOT_AVAILABLE
assert e.error.get_dbus_message() == 'Also blind drunk'
# MC gives up and closes the channel. This is the end of the CDO.
q.expect_many(
EventPattern('dbus-method-call', path=chan.object_path,
interface=cs.CHANNEL, method='Close', args=[]),
EventPattern('dbus-signal', interface=cs.CDO, signal='Finished'),
EventPattern('dbus-signal', interface=cs.CD_IFACE_OP_LIST,
signal='DispatchOperationFinished'),
)
# Now there are no more active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
# both old and new versions of NetworkManager. Compare
# add-connection.py, which only supports NM 1.0 and later.
#
# Configuration settings are described at
# https://developer.gnome.org/NetworkManager/1.0/ref-settings.html
#
import socket, struct, dbus, uuid
def ip_to_int(ip_string):
return struct.unpack("=I", socket.inet_aton(ip_string))[0]
# full duplex
s_wired = dbus.Dictionary({"duplex": "full"})
s_con = dbus.Dictionary({
"type": "802-3-ethernet",
"uuid": str(uuid.uuid4()),
"id": "MyConnectionExample"
})
addr1 = dbus.Array(
[ip_to_int("10.1.2.3"),
dbus.UInt32(8),
ip_to_int("10.1.2.1")],
signature=dbus.Signature("u"),
)
s_ip4 = dbus.Dictionary({
"addresses":
def py2_dbus_dictionary(self, setting_dict):
return dbus.Dictionary(setting_dict, signature = dbus.Signature('sv'))
def test_configuration_fstab(self):
# this test will change /etc/fstab, we might want to revert the changes when it finishes
fstab = self.read_file('/etc/fstab')
self.addCleanup(self.write_file, '/etc/fstab', fstab)
# format the disk
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
disk.Format('xfs',
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# cleanup -- remove format
self.addCleanup(self.wipe_fs, self.vdevs[0])
# configuration items as arrays of dbus.Byte
mnt = self.str_to_ay('/mnt/test')
fstype = self.str_to_ay('xfs')
opts = self.str_to_ay('defaults')
# set the new configuration
conf = dbus.Dictionary(
{
'dir': mnt,
'type': fstype,
'opts': opts,
'freq': 0,
'passno': 0
},
signature=dbus.Signature('sv'))
disk.AddConfigurationItem(('fstab', conf),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# get the configuration
old_conf = self.get_property(disk, '.Block', 'Configuration')
old_conf.assertTrue()
self.assertEqual(old_conf.value[0][1]['dir'], mnt)
self.assertEqual(old_conf.value[0][1]['type'], fstype)
self.assertEqual(old_conf.value[0][1]['opts'], opts)
self.assertEqual(old_conf.value[0][1]['passno'], 0)
self.assertEqual(old_conf.value[0][1]['freq'], 0)
# update the configuration
new_opts = self.str_to_ay('defaults,noauto')
new_conf = copy.deepcopy(old_conf.value)
new_conf[0][1]['opts'] = new_opts
disk.UpdateConfigurationItem(
(old_conf.value[0][0], old_conf.value[0][1]),
(new_conf[0][0], new_conf[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# get the configuration after the update
upd_conf = self.get_property(disk, '.Block', 'Configuration')
upd_conf.assertTrue()
upd_conf.assertEqual(new_opts, getter=lambda c: c[0][1]['opts'])
# this might fail in case of stray udev rules or records in /etc/fstab
hint_auto = self.get_property_raw(disk, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(False))
hint_ignore = self.get_property_raw(disk, '.Block', 'HintIgnore')
self.assertEqual(hint_ignore, dbus.Boolean(False))
hint_partitionable = self.get_property_raw(disk, '.Block',
'HintPartitionable')
self.assertEqual(hint_partitionable, dbus.Boolean(True))
hint_system = self.get_property_raw(disk, '.Block', 'HintSystem')
self.assertEqual(hint_system, dbus.Boolean(True))
# remove the configuration
disk.RemoveConfigurationItem(
(upd_conf.value[0][0], upd_conf.value[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
upd_conf = self.get_property(disk, '.Block', 'Configuration')
upd_conf.assertFalse()
class UdisksTestCase(unittest.TestCase):
iface_prefix = None
path_prefix = None
bus = None
vdevs = None
distro = (None, None, None) # (project, distro_name, version)
no_options = dbus.Dictionary(signature="sv")
@classmethod
def setUpClass(self):
self.iface_prefix = 'org.freedesktop.UDisks2'
self.path_prefix = '/org/freedesktop/UDisks2'
self.bus = dbus.SystemBus()
self.distro = get_version()
self._orig_call_async = self.bus.call_async
self._orig_call_blocking = self.bus.call_blocking
self.bus.call_async = get_call_long(self._orig_call_async)
self.bus.call_blocking = get_call_long(self._orig_call_blocking)
self.vdevs = test_devs
assert len(self.vdevs) > 3;
@classmethod
def tearDownClass(self):
self.bus.call_async = self._orig_call_async
self.bus.call_blocking = self._orig_call_blocking
def run(self, *args):
record = []
now = datetime.now()
now_mono = monotonic()
with open(FLIGHT_RECORD_FILE, "a") as record_f:
record_f.write("================%s[%0.8f] %s.%s.%s================\n" % (now.strftime('%Y-%m-%d %H:%M:%S'),
now_mono,
self.__class__.__module__,
self.__class__.__name__,
self._testMethodName))
with JournalRecorder("journal", record):
with CmdFlightRecorder("udisksctl monitor", ["udisksctl", "monitor"], record):
with CmdFlightRecorder("udevadm monitor", ["udevadm", "monitor"], record):
super(UdisksTestCase, self).run(*args)
record_f.write("".join(record))
self.udev_settle()
@classmethod
def get_object(self, path_suffix):
# if given full path, just use it, otherwise prepend the prefix
if path_suffix.startswith(self.path_prefix):
path = path_suffix
else:
path = self.path_prefix + path_suffix
try:
# self.iface_prefix is the same as the DBus name we acquire
obj = self.bus.get_object(self.iface_prefix, path)
except:
obj = None
return obj
@classmethod
def get_interface(self, obj, iface_suffix):
"""Get interface for the given object either specified by an object path suffix
(appended to the common UDisks2 prefix) or given as the object
itself.
:param obj: object to get the interface for
:type obj: str or dbus.proxies.ProxyObject
:param iface_suffix: suffix appended to the common UDisks2 interface prefix
:type iface_suffix: str
"""
if isinstance(obj, str):
obj = self.get_object(obj)
return dbus.Interface(obj, self.iface_prefix + iface_suffix)
@classmethod
def get_property(self, obj, iface_suffix, prop):
return DBusProperty(obj, self.iface_prefix + iface_suffix, prop)
@classmethod
def get_property_raw(self, obj, iface_suffix, prop):
res = obj.Get(self.iface_prefix + iface_suffix, prop, dbus_interface=dbus.PROPERTIES_IFACE)
return res
@classmethod
def get_device(self, dev_name):
"""Get block device object for a given device (e.g. "sda")"""
dev = self.get_object('/block_devices/' + os.path.basename(dev_name))
return dev
@classmethod
def get_drive_name(self, device):
"""Get drive name for the given block device object"""
drive_name = self.get_property_raw(device, '.Block', 'Drive').split('/')[-1]
return drive_name
@classmethod
def udev_settle(self):
self.run_command('udevadm settle')
@classmethod
def wipe_fs(self, device):
for _ in range(10):
ret, _out = self.run_command('wipefs -a %s' % device)
if ret == 0:
return True
time.sleep(1)
return False
@classmethod
def read_file(self, filename):
with open(filename, 'r') as f:
content = f.read()
return content
@classmethod
def write_file(self, filename, content, ignore_nonexistent=False):
try:
with open(filename, 'w') as f:
f.write(content)
except FileNotFoundError as e:
if not ignore_nonexistent:
raise e
@classmethod
def run_command(self, command):
return run_command(command)
@classmethod
def check_module_loaded(self, module):
manager_obj = self.get_object('/Manager')
manager = self.get_interface(manager_obj, '.Manager')
manager_intro = dbus.Interface(manager_obj, "org.freedesktop.DBus.Introspectable")
intro_data = manager_intro.Introspect()
modules_loaded = 'interface name="org.freedesktop.UDisks2.Manager.%s"' % module in intro_data
if not modules_loaded:
manager.EnableModules(dbus.Boolean(True))
intro_data = manager_intro.Introspect()
return 'interface name="org.freedesktop.UDisks2.Manager.%s"' % module in intro_data
else:
return True
@classmethod
def ay_to_str(self, ay):
"""Convert a bytearray (terminated with '\0') to a string"""
return ''.join(chr(x) for x in ay[:-1])
@classmethod
def str_to_ay(self, string, terminate=True):
"""Convert a string to a bytearray (terminated with '\0')"""
if terminate:
string += '\0'
return dbus.Array([dbus.Byte(ord(c)) for c in string],
signature=dbus.Signature('y'), variant_level=1)
@classmethod
def set_udev_property(self, device, prop, value):
udev = GUdev.Client()
dev = udev.query_by_device_file(device)
serial = dev.get_property("ID_SERIAL")
try:
os.makedirs("/run/udev/rules.d/")
except OSError:
# already exists
pass
self.write_file("/run/udev/rules.d/99-udisks_test.rules",
'ENV{ID_SERIAL}=="%s", ENV{%s}="%s"\n' % (serial, prop, value))
self.run_command("udevadm control --reload")
uevent_path = os.path.join(dev.get_sysfs_path(), "uevent")
self.write_file(uevent_path, "change\n")
self.udev_settle()
os.unlink("/run/udev/rules.d/99-udisks_test.rules")
self.run_command("udevadm control --reload")
@classmethod
def assertHasIface(self, obj, iface):
obj_intro = dbus.Interface(obj, "org.freedesktop.DBus.Introspectable")
intro_data = obj_intro.Introspect()
for _ in range(20):
if ('interface name="%s"' % iface) in intro_data:
return
time.sleep(0.5)
raise AssertionError("Object '%s' has no interface '%s'" % (obj.object_path, iface))
def assertStartswith(self, val, prefix):
if not val.startswith(prefix):
raise AssertionError("'%s' does not start with '%s'" % (val, prefix))
def test_configuration_fstab_removable(self):
# this test will change /etc/fstab, we might want to revert the changes when it finishes
fstab = self.read_file('/etc/fstab')
self.addCleanup(self.write_file, '/etc/fstab', fstab)
# this might fail in case of stray udev rules or records in /etc/fstab
hint_auto = self.get_property_raw(self.cd_device, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(True))
hint_ignore = self.get_property_raw(self.cd_device, '.Block',
'HintIgnore')
self.assertEqual(hint_ignore, dbus.Boolean(False))
hint_partitionable = self.get_property_raw(self.cd_device, '.Block',
'HintPartitionable')
self.assertEqual(hint_partitionable, dbus.Boolean(True))
hint_system = self.get_property_raw(self.cd_device, '.Block',
'HintSystem')
self.assertEqual(hint_system, dbus.Boolean(False))
# configuration items as arrays of dbus.Byte
mnt = self.str_to_ay('/mnt/test')
fstype = self.str_to_ay('xfs')
opts = self.str_to_ay('defaults')
# set the new configuration
conf = dbus.Dictionary(
{
'dir': mnt,
'type': fstype,
'opts': opts,
'freq': 0,
'passno': 0
},
signature=dbus.Signature('sv'))
self.cd_device.AddConfigurationItem(
('fstab', conf),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
hint_auto = self.get_property_raw(self.cd_device, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(True))
# get the configuration
old_conf = self.get_property(self.cd_device, '.Block', 'Configuration')
old_conf.assertTrue()
# update the configuration
new_opts = self.str_to_ay('defaults,noauto')
new_conf = copy.deepcopy(old_conf.value)
new_conf[0][1]['opts'] = new_opts
self.cd_device.UpdateConfigurationItem(
(old_conf.value[0][0], old_conf.value[0][1]),
(new_conf[0][0], new_conf[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# get the configuration after the update
upd_conf = self.get_property(self.cd_device, '.Block', 'Configuration')
upd_conf.assertTrue()
upd_conf.assertEqual(new_opts, getter=lambda c: c[0][1]['opts'])
# 'noauto' option specified, should be reflected in the HintAuto property
hint_auto = self.get_property_raw(self.cd_device, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(False))
# remove the configuration
self.cd_device.RemoveConfigurationItem(
(upd_conf.value[0][0], upd_conf.value[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
upd_conf = self.get_property(self.cd_device, '.Block', 'Configuration')
upd_conf.assertFalse()
hint_auto = self.get_property_raw(self.cd_device, '.Block', 'HintAuto')
self.assertEqual(hint_auto, dbus.Boolean(True))
def test(q, bus, mc):
params = dbus.Dictionary(
{
"account": "*****@*****.**",
"password": "******"
},
signature='sv')
simulated_cm, account = create_fakecm_account(q, bus, mc, params)
conn = enable_fakecm_account(q, bus, mc, account, params)
text_fixed_properties = dbus.Dictionary(
{
cs.CHANNEL + '.ChannelType': cs.CHANNEL_TYPE_TEXT,
cs.CHANNEL + '.TargetHandleType': cs.HT_CONTACT,
},
signature='sv')
# subscribe to the OperationList interface (MC assumes that until this
# property has been retrieved once, nobody cares)
cd = bus.get_object(cs.CD, cs.CD_PATH)
cd_props = dbus.Interface(cd, cs.PROPERTIES_IFACE)
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
client = SimulatedClient(q,
bus,
'Client',
observe=[text_fixed_properties],
approve=[text_fixed_properties],
handle=[],
bypass_approval=False)
# wait for MC to download the properties
expect_client_setup(q, [client])
channel_properties = dbus.Dictionary(text_fixed_properties, signature='sv')
channel_properties[cs.CHANNEL + '.TargetID'] = 'juliet'
channel_properties[cs.CHANNEL + '.TargetHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.InitiatorID'] = 'juliet'
channel_properties[cs.CHANNEL + '.InitiatorHandle'] = \
conn.ensure_handle(cs.HT_CONTACT, 'juliet')
channel_properties[cs.CHANNEL + '.Requested'] = False
channel_properties[cs.CHANNEL + '.Interfaces'] = dbus.Array(signature='s')
forbidden = [
EventPattern('dbus-method-call', method='AddDispatchOperation'),
]
q.forbid_events(forbidden)
chan = SimulatedChannel(conn, channel_properties)
chan.announce()
e = q.expect('dbus-signal',
path=cs.CD_PATH,
interface=cs.CD_IFACE_OP_LIST,
signal='NewDispatchOperation')
cdo_path = e.args[0]
cdo_properties = e.args[1]
assert cdo_properties[cs.CDO + '.Account'] == account.object_path
assert cdo_properties[cs.CDO + '.Connection'] == conn.object_path
assert cs.CDO + '.Interfaces' in cdo_properties
handlers = cdo_properties[cs.CDO + '.PossibleHandlers'][:]
assertEquals([], handlers)
e = q.expect('dbus-method-call',
path=client.object_path,
interface=cs.OBSERVER,
method='ObserveChannels',
handled=False)
sync_dbus(bus, q, mc)
q.dbus_return(e.message, signature='')
# now (but only now) MC kills the channel
q.expect_many(
EventPattern('dbus-signal', path=cdo_path, signal='Finished'),
EventPattern('dbus-method-call',
path=chan.object_path,
method='Close',
handled=True),
)
# There are no active channel dispatch operations
assert cd_props.Get(cs.CD_IFACE_OP_LIST, 'DispatchOperations') == []
SupportedMimeTypes = [
'audio/aac', 'audio/m4a', 'audio/mp3', 'audio/wav', 'audio/wma',
'audio/x-ape', 'audio/x-flac', 'audio/x-ogg', 'audio/x-oggflac',
'audio/x-vorbis'
]
BusName = 'org.mpris.MediaPlayer2.feeluown'
ObjectPath = '/org/mpris/MediaPlayer2'
AppInterface = 'org.mpris.MediaPlayer2'
PlayerInterface = 'org.mpris.MediaPlayer2.Player'
AppProperties = dbus.Dictionary(
{
'DesktopEntry': 'FeelUOwn',
'Identity': 'feeluown',
'CanQuit': False,
'CanRaise': False,
'HasTrackList': False,
'SupportedUriSchemes': ['http', 'file', 'smb'],
'SupportedMimeTypes': SupportedMimeTypes,
},
signature='sv')
logger = logging.getLogger(__name__)
def to_dbus_position(p):
return dbus.Int64(p * 1000 * 1000)
def to_fuo_position(p):
return p / 1000 / 1000
def PropDict(mapping=()):
return dbus.Dictionary(mapping, signature='sv')
def __init__(self, app, bus):
super().__init__(bus, ObjectPath)
self._app = app
self._metadata = dbus.Dictionary({}, signature='sv', variant_level=1)
self._old_position = dbus.Int64(0)
def add_service_data(self, uuid, data):
if not self.service_data:
self.service_data = dbus.Dictionary({}, signature="sv")
self.service_data[uuid] = dbus.Array(data, signature="y")
def __get_filters_handler_cb(self):
filter_dict = dbus.Dictionary({}, signature='sv')
return dbus.Array([filter_dict], signature='a{sv}')
def test_configuration_fstab(self):
# this test will change /etc/fstab, we might want to revert the changes when it finishes
fstab = self.read_file('/etc/fstab')
self.addCleanup(self.write_file, '/etc/fstab', fstab)
# format the disk
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
disk.Format('xfs',
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# cleanup -- remove format
self.addCleanup(self._clean_format, disk)
# configuration items as arrays of dbus.Byte
mnt = self.str_to_ay('/mnt/test')
fstype = self.str_to_ay('xfs')
opts = self.str_to_ay('defaults')
# set the new configuration
conf = dbus.Dictionary(
{
'dir': mnt,
'type': fstype,
'opts': opts,
'freq': 0,
'passno': 0
},
signature=dbus.Signature('sv'))
disk.AddConfigurationItem(('fstab', conf),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# get the configuration
old_conf = self.get_property(disk, '.Block', 'Configuration')
old_conf.assertTrue()
self.assertEqual(old_conf.value[0][1]['dir'], mnt)
self.assertEqual(old_conf.value[0][1]['type'], fstype)
self.assertEqual(old_conf.value[0][1]['opts'], opts)
self.assertEqual(old_conf.value[0][1]['passno'], 0)
self.assertEqual(old_conf.value[0][1]['freq'], 0)
# update the configuration
new_opts = self.str_to_ay('defaults,noauto')
new_conf = copy.deepcopy(old_conf.value)
new_conf[0][1]['opts'] = new_opts
disk.UpdateConfigurationItem(
(old_conf.value[0][0], old_conf.value[0][1]),
(new_conf[0][0], new_conf[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
time.sleep(5)
# get the configuration after the update
upd_conf = self.get_property(disk, '.Block', 'Configuration')
upd_conf.assertTrue()
self.assertEqual(upd_conf.value[0][1]['opts'], new_opts)
# remove the configuration
disk.RemoveConfigurationItem(
(upd_conf.value[0][0], upd_conf.value[0][1]),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
upd_conf = self.get_property(disk, '.Block', 'Configuration')
upd_conf.assertFalse()
def _create_ds_entry(properties, filename, transfer_ownership=False):
object_id = _get_data_store().create(dbus.Dictionary(properties), filename,
transfer_ownership)
return object_id
def get_unique_values(key):
"""Returns a list with the different values a property has taken
"""
empty_dict = dbus.Dictionary({}, signature='ss')
return _get_datastore().get_uniquevaluesfor(key, empty_dict)
INTERFACE = 'org.gajim.dbus.RemoteInterface'
OBJ_PATH = '/org/gajim/dbus/RemoteObject'
SERVICE = 'org.gajim.dbus'
# type mapping
# in most cases it is a utf-8 string
DBUS_STRING = dbus.String
# general type (for use in dicts, where all values should have the same type)
DBUS_BOOLEAN = dbus.Boolean
DBUS_DOUBLE = dbus.Double
DBUS_INT32 = dbus.Int32
# dictionary with string key and binary value
DBUS_DICT_SV = lambda: dbus.Dictionary({}, signature="sv")
# dictionary with string key and value
DBUS_DICT_SS = lambda: dbus.Dictionary({}, signature="ss")
# empty type (there is no equivalent of None on D-Bus, but historically gajim
# used 0 instead)
DBUS_NONE = lambda: dbus.Int32(0)
def get_dbus_struct(obj):
"""
Recursively go through all the items and replace them with their casted dbus
equivalents
"""
if obj is None:
return DBUS_NONE()
if isinstance(obj, str):
import dbus
from servicetest import call_async, EventPattern, tp_name_prefix, unwrap
from gabbletest import exec_test, acknowledge_iq
import constants as cs
import ns
from twisted.words.xish import domish
import tubetestutil as t
sample_parameters = dbus.Dictionary(
{
's': 'hello',
'ay': dbus.ByteArray(b'hello'),
'u': dbus.UInt32(123),
'i': dbus.Int32(-123),
},
signature='sv')
def test(q, bus, conn, stream):
conn.Connect()
properties = conn.GetAll(cs.CONN_IFACE_REQUESTS,
dbus_interface=cs.PROPERTIES_IFACE)
assert properties.get('Channels') == [], properties['Channels']
assert ({cs.CHANNEL_TYPE: cs.CHANNEL_TYPE_STREAM_TUBE,
cs.TARGET_HANDLE_TYPE: cs.HT_CONTACT,
},
[cs.TARGET_HANDLE, cs.TARGET_ID, cs.STREAM_TUBE_SERVICE]
def test_mount_fstab(self):
if not self._can_create:
self.skipTest('Cannot create %s filesystem' % self._fs_name)
if not self._can_mount:
self.skipTest('Cannot mount %s filesystem' % self._fs_name)
# this test will change /etc/fstab, we might want to revert the changes after it finishes
fstab = self.read_file('/etc/fstab')
self.addCleanup(self.write_file, '/etc/fstab', fstab)
disk = self.get_object('/block_devices/' +
os.path.basename(self.vdevs[0]))
self.assertIsNotNone(disk)
# create filesystem
disk.Format(self._fs_name,
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
self.addCleanup(self._clean_format, self.vdevs[0])
# create a tempdir
tmp = tempfile.mkdtemp()
self.addCleanup(self._rmtree, tmp)
# configuration items as arrays of dbus.Byte
mnt = self.str_to_ay(tmp)
fstype = self.str_to_ay(self._fs_name)
opts = self.str_to_ay('ro')
# set the new configuration
conf = dbus.Dictionary(
{
'dir': mnt,
'type': fstype,
'opts': opts,
'freq': 0,
'passno': 0
},
signature=dbus.Signature('sv'))
disk.AddConfigurationItem(('fstab', conf),
self.no_options,
dbus_interface=self.iface_prefix + '.Block')
# mount using fstab options
disk.Mount(self.no_options,
dbus_interface=self.iface_prefix + '.Filesystem')
self.addCleanup(self._unmount, self.vdevs[0])
# dbus mountpoint
dbus_mounts = self.get_property(disk, '.Filesystem', 'MountPoints')
dbus_mounts.assertLen(1) # just one mountpoint
dbus_mnt = self.ay_to_str(
dbus_mounts.value[0]) # mountpoints are arrays of bytes
self.assertEqual(dbus_mnt, tmp)
# system mountpoint
self.assertTrue(os.path.ismount(tmp))
_ret, out = self.run_command('mount | grep %s' % self.vdevs[0])
self.assertIn(tmp, out)
self.assertIn('ro', out)
