To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to mandos-ctl
- browse files at revision 237.7.666
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.666
- Committer: Teddy Hogeborn
- Date: 2019-07-15 15:19:42 UTC
- mto: This revision was merged to the branch mainline in revision 384.
- Revision ID: teddy@recompile.se-20190715151942-f1itgz5mo2d2zczj
Client: Document requirement of libnl-route library
* INSTALL (Prerequisites/Libraries/Mandos Client): Add "libnl-route".
* Makefile (plugin-helpers/mandos-client-iprouteadddel): Write comment
explaining that the explicit target exists to add the
libnl-route library.
* INSTALL (Prerequisites/Libraries/Mandos Client): Add "libnl-route".
* Makefile (plugin-helpers/mandos-client-iprouteadddel): Write comment
explaining that the explicit target exists to add the
libnl-route library.
- files removed:
- debian/po/POTFILES.in
- dracut-module
- files modified:
- .bzrignore
added
removed
mandos-ctl
1
#!/usr/bin/python3 -bbI
2
# -*- after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
1
#!/usr/bin/python
2
# -*- after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --test" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
5
5
#
46
46
import tempfile
47
47
import contextlib
48
48
49
if sys.version_info.major == 2:
50
__metaclass__ = type
51
str = unicode
52
53
class gi:
54
"""Dummy gi module, for the tests"""
55
class repository:
56
class GLib:
57
class Error(Exception):
58
pass
59
dbussy = None
60
ravel = None
61
dbus_python = None
62
pydbus = None
63
64
49
try:
65
import dbussy
66
import ravel
50
import pydbus
51
import gi
52
dbus_python = None
67
53
except ImportError:
68
try:
69
import pydbus
70
import gi
71
except ImportError:
72
import dbus as dbus_python
73
54
import dbus as dbus_python
55
pydbus = None
56
class gi(object):
57
"""Dummy gi module, for the tests"""
58
class repository(object):
59
class GLib(object):
60
class Error(Exception):
61
pass
74
62
75
63
# Show warnings by default
76
64
if not sys.warnoptions:
84
72
logging.captureWarnings(True) # Show warnings via the logging system
85
73
86
74
if sys.version_info.major == 2:
75
str = unicode
87
76
import StringIO
88
77
io.StringIO = StringIO.StringIO
89
78
90
79
locale.setlocale(locale.LC_ALL, "")
91
80
92
version = "1.8.10"
81
version = "1.8.4"
93
82
94
83
95
84
def main():
104
93
if options.debug:
105
94
log.setLevel(logging.DEBUG)
106
95
107
if dbussy is not None and ravel is not None:
108
bus = dbussy_adapter.CachingBus(dbussy, ravel)
109
elif pydbus is not None:
96
if pydbus is not None:
110
97
bus = pydbus_adapter.CachingBus(pydbus)
111
98
else:
112
99
bus = dbus_python_adapter.CachingBus(dbus_python)
263
250
def rfc3339_duration_to_delta(duration):
264
251
"""Parse an RFC 3339 "duration" and return a datetime.timedelta
265
252
266
>>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
267
True
268
>>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
269
True
270
>>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(hours=1)
271
True
272
>>> # 60 months
273
>>> rfc3339_duration_to_delta("P60M") == datetime.timedelta(1680)
274
True
275
>>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
276
True
277
>>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
278
True
279
>>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
280
True
281
>>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
282
True
253
>>> rfc3339_duration_to_delta("P7D")
254
datetime.timedelta(7)
255
>>> rfc3339_duration_to_delta("PT60S")
256
datetime.timedelta(0, 60)
257
>>> rfc3339_duration_to_delta("PT60M")
258
datetime.timedelta(0, 3600)
259
>>> rfc3339_duration_to_delta("P60M")
260
datetime.timedelta(1680)
261
>>> rfc3339_duration_to_delta("PT24H")
262
datetime.timedelta(1)
263
>>> rfc3339_duration_to_delta("P1W")
264
datetime.timedelta(7)
265
>>> rfc3339_duration_to_delta("PT5M30S")
266
datetime.timedelta(0, 330)
267
>>> rfc3339_duration_to_delta("P1DT3M20S")
268
datetime.timedelta(1, 200)
283
269
>>> # Can not be empty:
284
270
>>> rfc3339_duration_to_delta("")
285
271
Traceback (most recent call last):
395
381
"""Parse an interval string as documented by Mandos before 1.6.1,
396
382
and return a datetime.timedelta
397
383
398
>>> parse_pre_1_6_1_interval('7d') == datetime.timedelta(days=7)
399
True
400
>>> parse_pre_1_6_1_interval('60s') == datetime.timedelta(0, 60)
401
True
402
>>> parse_pre_1_6_1_interval('60m') == datetime.timedelta(hours=1)
403
True
404
>>> parse_pre_1_6_1_interval('24h') == datetime.timedelta(days=1)
405
True
406
>>> parse_pre_1_6_1_interval('1w') == datetime.timedelta(days=7)
407
True
408
>>> parse_pre_1_6_1_interval('5m 30s') == datetime.timedelta(0, 330)
409
True
410
>>> parse_pre_1_6_1_interval('') == datetime.timedelta(0)
411
True
384
>>> parse_pre_1_6_1_interval('7d')
385
datetime.timedelta(7)
386
>>> parse_pre_1_6_1_interval('60s')
387
datetime.timedelta(0, 60)
388
>>> parse_pre_1_6_1_interval('60m')
389
datetime.timedelta(0, 3600)
390
>>> parse_pre_1_6_1_interval('24h')
391
datetime.timedelta(1)
392
>>> parse_pre_1_6_1_interval('1w')
393
datetime.timedelta(7)
394
>>> parse_pre_1_6_1_interval('5m 30s')
395
datetime.timedelta(0, 330)
396
>>> parse_pre_1_6_1_interval('')
397
datetime.timedelta(0)
412
398
>>> # Ignore unknown characters, allow any order and repetitions
413
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m') == datetime.timedelta(2, 480, 18000)
414
True
399
>>> parse_pre_1_6_1_interval('2dxy7zz11y3m5m')
400
datetime.timedelta(2, 480, 18000)
415
401
416
402
"""
417
403
480
466
parser.error("--remove can only be combined with --deny")
481
467
482
468
483
class dbus:
469
class dbus(object):
484
470
485
class SystemBus:
471
class SystemBus(object):
486
472
487
473
object_manager_iface = "org.freedesktop.DBus.ObjectManager"
488
474
def get_managed_objects(self, busname, objectpath):
497
483
self.properties_iface, interface, key,
498
484
value)
499
485
500
def call_method(self, methodname, busname, objectpath,
501
interface, *args):
502
raise NotImplementedError()
503
504
486
505
487
class MandosBus(SystemBus):
506
488
busname_domain = "se.recompile"
538
520
pass
539
521
540
522
541
class dbus_python_adapter:
523
class dbus_python_adapter(object):
542
524
543
525
class SystemBus(dbus.MandosBus):
544
526
"""Use dbus-python"""
598
580
self.client_interface, key,
599
581
value)
600
582
601
class SilenceLogger:
583
class SilenceLogger(object):
602
584
"Simple context manager to silence a particular logger"
603
585
def __init__(self, loggername):
604
586
self.logger = logging.getLogger(loggername)
633
615
return new_object
634
616
635
617
636
class pydbus_adapter:
618
class pydbus_adapter(object):
637
619
class SystemBus(dbus.MandosBus):
638
620
def __init__(self, module=pydbus):
639
621
self.pydbus = module
696
678
return new_object
697
679
698
680
699
class dbussy_adapter:
700
class SystemBus(dbus.SystemBus):
701
"""Use DBussy"""
702
703
def __init__(self, dbussy, ravel):
704
self.dbussy = dbussy
705
self.ravel = ravel
706
self.bus = ravel.system_bus()
707
708
@contextlib.contextmanager
709
def convert_exception(self, exception_class=dbus.Error):
710
try:
711
yield
712
except self.dbussy.DBusError as e:
713
# This does what "raise from" would do
714
exc = exception_class(*e.args)
715
exc.__cause__ = e
716
raise exc
717
718
def call_method(self, methodname, busname, objectpath,
719
interface, *args):
720
proxy_object = self.get_object(busname, objectpath)
721
log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
722
interface, methodname,
723
", ".join(repr(a) for a in args))
724
iface = proxy_object.get_interface(interface)
725
method = getattr(iface, methodname)
726
with self.convert_exception(dbus.Error):
727
value = method(*args)
728
# DBussy returns values either as an empty list or as a
729
# tuple: (signature, value)
730
if value:
731
return self.type_filter(value[0])
732
733
def get_object(self, busname, objectpath):
734
log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
735
busname, objectpath)
736
with self.convert_exception(dbus.ConnectFailed):
737
return self.bus[busname][objectpath]
738
739
def type_filter(self, value):
740
"""Convert the most bothersome types to Python types"""
741
if isinstance(value, tuple):
742
if (len(value) == 2
743
and isinstance(value[0],
744
self.dbussy.DBUS.Signature)):
745
return self.type_filter(value[1])
746
elif isinstance(value, self.dbussy.DBUS.ObjectPath):
747
return str(value)
748
# Also recurse into dictionaries
749
elif isinstance(value, dict):
750
return {self.type_filter(key):
751
self.type_filter(subval)
752
for key, subval in value.items()}
753
return value
754
755
def set_property(self, busname, objectpath, interface, key,
756
value):
757
proxy_object = self.get_object(busname, objectpath)
758
log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
759
objectpath, self.properties_iface, interface,
760
key, value)
761
if key == "Secret":
762
# DBussy wants a Byte Array to be a sequence of
763
# values, not a byte string
764
value = tuple(value)
765
setattr(proxy_object.get_interface(interface), key, value)
766
767
class MandosBus(SystemBus, dbus.MandosBus):
768
pass
769
770
class CachingBus(MandosBus):
771
"""A caching layer for dbussy_adapter.MandosBus"""
772
def __init__(self, *args, **kwargs):
773
self.object_cache = {}
774
super(dbussy_adapter.CachingBus, self).__init__(*args,
775
**kwargs)
776
def get_object(self, busname, objectpath):
777
try:
778
return self.object_cache[(busname, objectpath)]
779
except KeyError:
780
new_object = super(
781
dbussy_adapter.CachingBus,
782
self).get_object(busname, objectpath)
783
self.object_cache[(busname, objectpath)] = new_object
784
return new_object
785
786
787
681
def commands_from_options(options):
788
682
789
683
commands = list(options.commands)
817
711
return commands
818
712
819
713
820
class command:
714
class command(object):
821
715
"""A namespace for command classes"""
822
716
823
class Base:
717
class Base(object):
824
718
"""Abstract base class for commands"""
825
719
def run(self, clients, bus=None):
826
720
"""Normal commands should implement run_on_one_client(),
889
783
keywords = self.all_keywords
890
784
print(self.TableOfClients(clients.values(), keywords))
891
785
892
class TableOfClients:
786
class TableOfClients(object):
893
787
tableheaders = {
894
788
"Name": "Name",
895
789
"Enabled": "Enabled",
1126
1020
"output"))
1127
1021
1128
1022
1129
class Unique:
1023
class Unique(object):
1130
1024
"""Class for objects which exist only to be unique objects, since
1131
1025
unittest.mock.sentinel only exists in Python 3.3"""
1132
1026
1416
1310
class Test_dbus_python_adapter_SystemBus(TestCaseWithAssertLogs):
1417
1311
1418
1312
def MockDBusPython_func(self, func):
1419
class mock_dbus_python:
1313
class mock_dbus_python(object):
1420
1314
"""mock dbus-python module"""
1421
class exceptions:
1315
class exceptions(object):
1422
1316
"""Pseudo-namespace"""
1423
1317
class DBusException(Exception):
1424
1318
pass
1425
class SystemBus:
1319
class SystemBus(object):
1426
1320
@staticmethod
1427
1321
def get_object(busname, objectpath):
1428
1322
DBusObject = collections.namedtuple(
1442
1336
dbus_interface=dbus_interface)
1443
1337
return DBusObject(methodname=method,
1444
1338
Set=set_property)
1445
class Boolean:
1339
class Boolean(object):
1446
1340
def __init__(self, value):
1447
1341
self.value = bool(value)
1448
1342
def __bool__(self):
1632
1526
finally:
1633
1527
dbus_logger.removeFilter(counting_handler)
1634
1528
1635
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
1529
self.assertNotIsInstance(e, dbus.ConnectFailed)
1636
1530
1637
1531
# Make sure the dbus logger was suppressed
1638
1532
self.assertEqual(0, counting_handler.count)
1660
1554
self.call_method(bus, "methodname", "busname",
1661
1555
"objectpath", "interface")
1662
1556
1663
class fake_dbus_python_raises_exception_on_connect:
1557
class fake_dbus_python_raises_exception_on_connect(object):
1664
1558
"""fake dbus-python module"""
1665
class exceptions:
1559
class exceptions(object):
1666
1560
"""Pseudo-namespace"""
1667
1561
class DBusException(Exception):
1668
1562
pass
1676
1570
1677
1571
1678
1572
class Test_dbus_python_adapter_CachingBus(unittest.TestCase):
1679
class mock_dbus_python:
1573
class mock_dbus_python(object):
1680
1574
"""mock dbus-python modules"""
1681
class SystemBus:
1575
class SystemBus(object):
1682
1576
@staticmethod
1683
1577
def get_object(busname, objectpath):
1684
1578
return Unique()
1730
1624
class Test_pydbus_adapter_SystemBus(TestCaseWithAssertLogs):
1731
1625
1732
1626
def Stub_pydbus_func(self, func):
1733
class stub_pydbus:
1627
class stub_pydbus(object):
1734
1628
"""stub pydbus module"""
1735
class SystemBus:
1629
class SystemBus(object):
1736
1630
@staticmethod
1737
1631
def get(busname, objectpath):
1738
1632
DBusObject = collections.namedtuple(
1775
1669
self.call_method(bus, "methodname", "busname",
1776
1670
"objectpath", "interface")
1777
1671
1778
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
1672
self.assertNotIsInstance(e, dbus.ConnectFailed)
1779
1673
1780
1674
def test_get_converts_to_correct_exception(self):
1781
1675
bus = pydbus_adapter.SystemBus(
1784
1678
self.call_method(bus, "methodname", "busname",
1785
1679
"objectpath", "interface")
1786
1680
1787
class fake_pydbus_raises_exception_on_connect:
1681
class fake_pydbus_raises_exception_on_connect(object):
1788
1682
"""fake dbus-python module"""
1789
1683
@classmethod
1790
1684
def SystemBus(cls):
1794
1688
return Bus(get=get)
1795
1689
1796
1690
def test_set_property_uses_setattr(self):
1797
class Object:
1691
class Object(object):
1798
1692
pass
1799
1693
obj = Object()
1800
class pydbus_spy:
1801
class SystemBus:
1694
class pydbus_spy(object):
1695
class SystemBus(object):
1802
1696
@staticmethod
1803
1697
def get(busname, objectpath):
1804
1698
return {"interface": obj}
1811
1705
def test_get_suppresses_xml_deprecation_warning(self):
1812
1706
if sys.version_info.major >= 3:
1813
1707
return
1814
class stub_pydbus_get:
1815
class SystemBus:
1708
class stub_pydbus_get(object):
1709
class SystemBus(object):
1816
1710
@staticmethod
1817
1711
def get(busname, objectpath):
1818
1712
warnings.warn_explicit(
1826
1720
1827
1721
1828
1722
class Test_pydbus_adapter_CachingBus(unittest.TestCase):
1829
class stub_pydbus:
1723
class stub_pydbus(object):
1830
1724
"""stub pydbus module"""
1831
class SystemBus:
1725
class SystemBus(object):
1832
1726
@staticmethod
1833
1727
def get(busname, objectpath):
1834
1728
return Unique()
1876
1770
self.assertIs(obj1, obj1b)
1877
1771
1878
1772
1879
class Test_dbussy_adapter_SystemBus(TestCaseWithAssertLogs):
1880
1881
class dummy_dbussy:
1882
class DBUS:
1883
class ObjectPath(str):
1884
pass
1885
class DBusError(Exception):
1886
pass
1887
1888
def fake_ravel_func(self, func):
1889
class fake_ravel:
1890
@staticmethod
1891
def system_bus():
1892
class DBusInterfaceProxy:
1893
@staticmethod
1894
def methodname(*args):
1895
return [func(*args)]
1896
class DBusObject:
1897
@staticmethod
1898
def get_interface(interface):
1899
if interface == "interface":
1900
return DBusInterfaceProxy()
1901
return {"busname": {"objectpath": DBusObject()}}
1902
return fake_ravel
1903
1904
def call_method(self, bus, methodname, busname, objectpath,
1905
interface, *args):
1906
with self.assertLogs(log, logging.DEBUG):
1907
return bus.call_method(methodname, busname, objectpath,
1908
interface, *args)
1909
1910
def test_call_method_returns(self):
1911
expected_method_return = Unique()
1912
method_args = (Unique(), Unique())
1913
def func(*args):
1914
self.assertEqual(len(method_args), len(args))
1915
for marg, arg in zip(method_args, args):
1916
self.assertIs(marg, arg)
1917
return expected_method_return
1918
fake_ravel = self.fake_ravel_func(func)
1919
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1920
ret = self.call_method(bus, "methodname", "busname",
1921
"objectpath", "interface",
1922
*method_args)
1923
self.assertIs(ret, expected_method_return)
1924
1925
def test_call_method_filters_objectpath(self):
1926
def func():
1927
return method_return
1928
fake_ravel = self.fake_ravel_func(func)
1929
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1930
method_return = (self.dummy_dbussy.DBUS
1931
.ObjectPath("objectpath"))
1932
ret = self.call_method(bus, "methodname", "busname",
1933
"objectpath", "interface")
1934
self.assertEqual("objectpath", ret)
1935
self.assertNotIsInstance(ret,
1936
self.dummy_dbussy.DBUS.ObjectPath)
1937
1938
def test_call_method_filters_objectpaths_in_dict(self):
1939
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1940
def func():
1941
return method_return
1942
fake_ravel = self.fake_ravel_func(func)
1943
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1944
method_return = {
1945
ObjectPath("objectpath_key_1"):
1946
ObjectPath("objectpath_value_1"),
1947
ObjectPath("objectpath_key_2"):
1948
ObjectPath("objectpath_value_2"),
1949
}
1950
ret = self.call_method(bus, "methodname", "busname",
1951
"objectpath", "interface")
1952
expected_method_return = {str(key): str(value)
1953
for key, value in
1954
method_return.items()}
1955
for key, value in ret.items():
1956
self.assertNotIsInstance(key, ObjectPath)
1957
self.assertNotIsInstance(value, ObjectPath)
1958
self.assertEqual(expected_method_return, ret)
1959
self.assertIsInstance(ret, dict)
1960
1961
def test_call_method_filters_objectpaths_in_dict_in_dict(self):
1962
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1963
def func():
1964
return method_return
1965
fake_ravel = self.fake_ravel_func(func)
1966
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1967
method_return = {
1968
ObjectPath("key1"): {
1969
ObjectPath("key11"): ObjectPath("value11"),
1970
ObjectPath("key12"): ObjectPath("value12"),
1971
},
1972
ObjectPath("key2"): {
1973
ObjectPath("key21"): ObjectPath("value21"),
1974
ObjectPath("key22"): ObjectPath("value22"),
1975
},
1976
}
1977
ret = self.call_method(bus, "methodname", "busname",
1978
"objectpath", "interface")
1979
expected_method_return = {
1980
"key1": {"key11": "value11",
1981
"key12": "value12"},
1982
"key2": {"key21": "value21",
1983
"key22": "value22"},
1984
}
1985
self.assertEqual(expected_method_return, ret)
1986
for key, value in ret.items():
1987
self.assertIsInstance(value, dict)
1988
self.assertEqual(expected_method_return[key], value)
1989
self.assertNotIsInstance(key, ObjectPath)
1990
for inner_key, inner_value in value.items():
1991
self.assertIsInstance(value, dict)
1992
self.assertEqual(
1993
expected_method_return[key][inner_key],
1994
inner_value)
1995
self.assertNotIsInstance(key, ObjectPath)
1996
1997
def test_call_method_filters_objectpaths_in_dict_three_deep(self):
1998
ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1999
def func():
2000
return method_return
2001
fake_ravel = self.fake_ravel_func(func)
2002
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2003
method_return = {
2004
ObjectPath("key1"): {
2005
ObjectPath("key2"): {
2006
ObjectPath("key3"): ObjectPath("value"),
2007
},
2008
},
2009
}
2010
ret = self.call_method(bus, "methodname", "busname",
2011
"objectpath", "interface")
2012
expected_method_return = {"key1": {"key2": {"key3": "value"}}}
2013
self.assertEqual(expected_method_return, ret)
2014
self.assertIsInstance(ret, dict)
2015
self.assertNotIsInstance(next(iter(ret.keys())), ObjectPath)
2016
self.assertIsInstance(ret["key1"], dict)
2017
self.assertNotIsInstance(next(iter(ret["key1"].keys())),
2018
ObjectPath)
2019
self.assertIsInstance(ret["key1"]["key2"], dict)
2020
self.assertNotIsInstance(
2021
next(iter(ret["key1"]["key2"].keys())),
2022
ObjectPath)
2023
self.assertEqual("value", ret["key1"]["key2"]["key3"])
2024
self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
2025
self.dummy_dbussy.DBUS.ObjectPath)
2026
2027
def test_call_method_handles_exception(self):
2028
def func():
2029
raise self.dummy_dbussy.DBusError()
2030
2031
fake_ravel = self.fake_ravel_func(func)
2032
bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2033
2034
with self.assertRaises(dbus.Error) as e:
2035
self.call_method(bus, "methodname", "busname",
2036
"objectpath", "interface")
2037
2038
self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
2039
2040
def test_get_object_converts_to_correct_exception(self):
2041
class fake_ravel_raises_exception_on_connect:
2042
@staticmethod
2043
def system_bus():
2044
class Bus:
2045
@staticmethod
2046
def __getitem__(key):
2047
if key == "objectpath":
2048
raise self.dummy_dbussy.DBusError()
2049
raise Exception(key)
2050
return {"busname": Bus()}
2051
def func():
2052
raise self.dummy_dbussy.DBusError()
2053
bus = dbussy_adapter.SystemBus(
2054
self.dummy_dbussy,
2055
fake_ravel_raises_exception_on_connect)
2056
with self.assertRaises(dbus.ConnectFailed):
2057
self.call_method(bus, "methodname", "busname",
2058
"objectpath", "interface")
2059
2060
2061
1773
class Test_commands_from_options(unittest.TestCase):
2062
1774
2063
1775
def setUp(self):
2289
2001
2290
2002
2291
2003
def test_manual_page_example_1(self):
2292
self.assert_command_from_args("",
2004
self.assert_command_from_args("--verbose".split(),
2293
2005
command.PrintTable,
2294
2006
clients=[],
2295
verbose=False)
2007
verbose=True)
2296
2008
2297
2009
def test_manual_page_example_2(self):
2298
2010
self.assert_command_from_args(
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0