/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos-ctl

  • Committer: Teddy Hogeborn
  • Date: 2019-08-18 20:06:18 UTC
  • mto: This revision was merged to the branch mainline in revision 1162.
  • Revision ID: teddy@recompile.se-20190818200618-6n0qp1suxc2psmlq
Tags: version-1.8.8-1
http://bugs.debian.org/934373
http://bugs.debian.org/934888
* Makefile (version): Change to 1.8.8.
* NEWS (Version 1.8.8): Add new entry.
* debian/changelog (1.8.8-1): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos-ctl
1
 
#!/usr/bin/python3 -bbI
 
1
#!/usr/bin/python
2
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 -*-
3
3
#
4
4
# Mandos Monitor - Control and monitor the Mandos server
48
48
 
49
49
if sys.version_info.major == 2:
50
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
51
 
64
52
try:
65
 
    import dbussy
66
 
    import ravel
 
53
    import pydbus
 
54
    import gi
 
55
    dbus_python = None
67
56
except ImportError:
68
 
    try:
69
 
        import pydbus
70
 
        import gi
71
 
    except ImportError:
72
 
        import dbus as dbus_python
73
 
 
 
57
    import dbus as dbus_python
 
58
    pydbus = None
 
59
    class gi:
 
60
        """Dummy gi module, for the tests"""
 
61
        class repository:
 
62
            class GLib:
 
63
                class Error(Exception):
 
64
                    pass
74
65
 
75
66
# Show warnings by default
76
67
if not sys.warnoptions:
84
75
logging.captureWarnings(True)   # Show warnings via the logging system
85
76
 
86
77
if sys.version_info.major == 2:
 
78
    str = unicode
87
79
    import StringIO
88
80
    io.StringIO = StringIO.StringIO
89
81
 
90
82
locale.setlocale(locale.LC_ALL, "")
91
83
 
92
 
version = "1.8.9"
 
84
version = "1.8.8"
93
85
 
94
86
 
95
87
def main():
104
96
    if options.debug:
105
97
        log.setLevel(logging.DEBUG)
106
98
 
107
 
    if dbussy is not None and ravel is not None:
108
 
        bus = dbussy_adapter.CachingBus(dbussy, ravel)
109
 
    elif pydbus is not None:
 
99
    if pydbus is not None:
110
100
        bus = pydbus_adapter.CachingBus(pydbus)
111
101
    else:
112
102
        bus = dbus_python_adapter.CachingBus(dbus_python)
497
487
                             self.properties_iface, interface, key,
498
488
                             value)
499
489
 
 
490
 
500
491
    class MandosBus(SystemBus):
501
492
        busname_domain = "se.recompile"
502
493
        busname = busname_domain + ".Mandos"
691
682
                return new_object
692
683
 
693
684
 
694
 
class dbussy_adapter:
695
 
    class SystemBus(dbus.SystemBus):
696
 
        """Use DBussy"""
697
 
 
698
 
        def __init__(self, dbussy, ravel):
699
 
            self.dbussy = dbussy
700
 
            self.ravel = ravel
701
 
            self.bus = ravel.system_bus()
702
 
 
703
 
        @contextlib.contextmanager
704
 
        def convert_exception(self, exception_class=dbus.Error):
705
 
            try:
706
 
                yield
707
 
            except self.dbussy.DBusError as e:
708
 
                # This does what "raise from" would do
709
 
                exc = exception_class(*e.args)
710
 
                exc.__cause__ = e
711
 
                raise exc
712
 
 
713
 
        def call_method(self, methodname, busname, objectpath,
714
 
                        interface, *args):
715
 
            proxy_object = self.get_object(busname, objectpath)
716
 
            log.debug("D-Bus: %s:%s:%s.%s(%s)", busname, objectpath,
717
 
                      interface, methodname,
718
 
                      ", ".join(repr(a) for a in args))
719
 
            iface = proxy_object.get_interface(interface)
720
 
            method = getattr(iface, methodname)
721
 
            with self.convert_exception(dbus.Error):
722
 
                value =  method(*args)
723
 
            # DBussy returns values either as an empty list or as a
724
 
            # tuple: (signature, value)
725
 
            if value:
726
 
                return self.type_filter(value[0])
727
 
 
728
 
        def get_object(self, busname, objectpath):
729
 
            log.debug("D-Bus: Connect to: (busname=%r, path=%r)",
730
 
                      busname, objectpath)
731
 
            with self.convert_exception(dbus.ConnectFailed):
732
 
                return self.bus[busname][objectpath]
733
 
 
734
 
        def type_filter(self, value):
735
 
            """Convert the most bothersome types to Python types"""
736
 
            if isinstance(value, tuple):
737
 
                if (len(value) == 2
738
 
                    and isinstance(value[0],
739
 
                                   self.dbussy.DBUS.Signature)):
740
 
                    return self.type_filter(value[1])
741
 
            elif isinstance(value, self.dbussy.DBUS.ObjectPath):
742
 
                return str(value)
743
 
            # Also recurse into dictionaries
744
 
            elif isinstance(value, dict):
745
 
                return {self.type_filter(key):
746
 
                        self.type_filter(subval)
747
 
                        for key, subval in value.items()}
748
 
            return value
749
 
 
750
 
        def set_property(self, busname, objectpath, interface, key,
751
 
                         value):
752
 
            proxy_object = self.get_object(busname, objectpath)
753
 
            log.debug("D-Bus: %s:%s:%s.Set(%r, %r, %r)", busname,
754
 
                      objectpath, self.properties_iface, interface,
755
 
                      key, value)
756
 
            if key == "Secret":
757
 
                # DBussy wants a Byte Array to be a sequence of
758
 
                # values, not a byte string
759
 
                value = tuple(value)
760
 
            setattr(proxy_object.get_interface(interface), key, value)
761
 
 
762
 
    class MandosBus(SystemBus, dbus.MandosBus):
763
 
        pass
764
 
 
765
 
    class CachingBus(MandosBus):
766
 
        """A caching layer for dbussy_adapter.MandosBus"""
767
 
        def __init__(self, *args, **kwargs):
768
 
            self.object_cache = {}
769
 
            super(dbussy_adapter.CachingBus, self).__init__(*args,
770
 
                                                            **kwargs)
771
 
        def get_object(self, busname, objectpath):
772
 
            try:
773
 
                return self.object_cache[(busname, objectpath)]
774
 
            except KeyError:
775
 
                new_object = super(
776
 
                    dbussy_adapter.CachingBus,
777
 
                    self).get_object(busname, objectpath)
778
 
                self.object_cache[(busname, objectpath)]  = new_object
779
 
                return new_object
780
 
 
781
 
 
782
685
def commands_from_options(options):
783
686
 
784
687
    commands = list(options.commands)
1871
1774
        self.assertIs(obj1, obj1b)
1872
1775
 
1873
1776
 
1874
 
class Test_dbussy_adapter_SystemBus(TestCaseWithAssertLogs):
1875
 
 
1876
 
    class dummy_dbussy:
1877
 
        class DBUS:
1878
 
            class ObjectPath(str):
1879
 
                pass
1880
 
        class DBusError(Exception):
1881
 
            pass
1882
 
 
1883
 
    def fake_ravel_func(self, func):
1884
 
        class fake_ravel:
1885
 
            @staticmethod
1886
 
            def system_bus():
1887
 
                class DBusInterfaceProxy:
1888
 
                    @staticmethod
1889
 
                    def methodname(*args):
1890
 
                        return [func(*args)]
1891
 
                class DBusObject:
1892
 
                    @staticmethod
1893
 
                    def get_interface(interface):
1894
 
                        if interface == "interface":
1895
 
                            return DBusInterfaceProxy()
1896
 
                return {"busname": {"objectpath": DBusObject()}}
1897
 
        return fake_ravel
1898
 
 
1899
 
    def call_method(self, bus, methodname, busname, objectpath,
1900
 
                    interface, *args):
1901
 
        with self.assertLogs(log, logging.DEBUG):
1902
 
            return bus.call_method(methodname, busname, objectpath,
1903
 
                                   interface, *args)
1904
 
 
1905
 
    def test_call_method_returns(self):
1906
 
        expected_method_return = Unique()
1907
 
        method_args = (Unique(), Unique())
1908
 
        def func(*args):
1909
 
            self.assertEqual(len(method_args), len(args))
1910
 
            for marg, arg in zip(method_args, args):
1911
 
                self.assertIs(marg, arg)
1912
 
            return expected_method_return
1913
 
        fake_ravel = self.fake_ravel_func(func)
1914
 
        bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1915
 
        ret = self.call_method(bus, "methodname", "busname",
1916
 
                               "objectpath", "interface",
1917
 
                               *method_args)
1918
 
        self.assertIs(ret, expected_method_return)
1919
 
 
1920
 
    def test_call_method_filters_objectpath(self):
1921
 
        def func():
1922
 
            return method_return
1923
 
        fake_ravel = self.fake_ravel_func(func)
1924
 
        bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1925
 
        method_return = (self.dummy_dbussy.DBUS
1926
 
                         .ObjectPath("objectpath"))
1927
 
        ret = self.call_method(bus, "methodname", "busname",
1928
 
                               "objectpath", "interface")
1929
 
        self.assertEqual("objectpath", ret)
1930
 
        self.assertNotIsInstance(ret,
1931
 
                                 self.dummy_dbussy.DBUS.ObjectPath)
1932
 
 
1933
 
    def test_call_method_filters_objectpaths_in_dict(self):
1934
 
        ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1935
 
        def func():
1936
 
            return method_return
1937
 
        fake_ravel = self.fake_ravel_func(func)
1938
 
        bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1939
 
        method_return = {
1940
 
            ObjectPath("objectpath_key_1"):
1941
 
            ObjectPath("objectpath_value_1"),
1942
 
            ObjectPath("objectpath_key_2"):
1943
 
            ObjectPath("objectpath_value_2"),
1944
 
        }
1945
 
        ret = self.call_method(bus, "methodname", "busname",
1946
 
                               "objectpath", "interface")
1947
 
        expected_method_return = {str(key): str(value)
1948
 
                                  for key, value in
1949
 
                                  method_return.items()}
1950
 
        for key, value in ret.items():
1951
 
            self.assertNotIsInstance(key, ObjectPath)
1952
 
            self.assertNotIsInstance(value, ObjectPath)
1953
 
        self.assertEqual(expected_method_return, ret)
1954
 
        self.assertIsInstance(ret, dict)
1955
 
 
1956
 
    def test_call_method_filters_objectpaths_in_dict_in_dict(self):
1957
 
        ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1958
 
        def func():
1959
 
            return method_return
1960
 
        fake_ravel = self.fake_ravel_func(func)
1961
 
        bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1962
 
        method_return = {
1963
 
            ObjectPath("key1"): {
1964
 
                ObjectPath("key11"): ObjectPath("value11"),
1965
 
                ObjectPath("key12"): ObjectPath("value12"),
1966
 
            },
1967
 
            ObjectPath("key2"): {
1968
 
                ObjectPath("key21"): ObjectPath("value21"),
1969
 
                ObjectPath("key22"): ObjectPath("value22"),
1970
 
            },
1971
 
        }
1972
 
        ret = self.call_method(bus, "methodname", "busname",
1973
 
                               "objectpath", "interface")
1974
 
        expected_method_return = {
1975
 
            "key1": {"key11": "value11",
1976
 
                     "key12": "value12"},
1977
 
            "key2": {"key21": "value21",
1978
 
                     "key22": "value22"},
1979
 
        }
1980
 
        self.assertEqual(expected_method_return, ret)
1981
 
        for key, value in ret.items():
1982
 
            self.assertIsInstance(value, dict)
1983
 
            self.assertEqual(expected_method_return[key], value)
1984
 
            self.assertNotIsInstance(key, ObjectPath)
1985
 
            for inner_key, inner_value in value.items():
1986
 
                self.assertIsInstance(value, dict)
1987
 
                self.assertEqual(
1988
 
                    expected_method_return[key][inner_key],
1989
 
                    inner_value)
1990
 
                self.assertNotIsInstance(key, ObjectPath)
1991
 
 
1992
 
    def test_call_method_filters_objectpaths_in_dict_three_deep(self):
1993
 
        ObjectPath = self.dummy_dbussy.DBUS.ObjectPath
1994
 
        def func():
1995
 
            return method_return
1996
 
        fake_ravel = self.fake_ravel_func(func)
1997
 
        bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
1998
 
        method_return = {
1999
 
            ObjectPath("key1"): {
2000
 
                ObjectPath("key2"): {
2001
 
                    ObjectPath("key3"): ObjectPath("value"),
2002
 
                },
2003
 
            },
2004
 
        }
2005
 
        ret = self.call_method(bus, "methodname", "busname",
2006
 
                               "objectpath", "interface")
2007
 
        expected_method_return = {"key1": {"key2": {"key3": "value"}}}
2008
 
        self.assertEqual(expected_method_return, ret)
2009
 
        self.assertIsInstance(ret, dict)
2010
 
        self.assertNotIsInstance(next(iter(ret.keys())), ObjectPath)
2011
 
        self.assertIsInstance(ret["key1"], dict)
2012
 
        self.assertNotIsInstance(next(iter(ret["key1"].keys())),
2013
 
                                 ObjectPath)
2014
 
        self.assertIsInstance(ret["key1"]["key2"], dict)
2015
 
        self.assertNotIsInstance(
2016
 
            next(iter(ret["key1"]["key2"].keys())),
2017
 
            ObjectPath)
2018
 
        self.assertEqual("value", ret["key1"]["key2"]["key3"])
2019
 
        self.assertNotIsInstance(ret["key1"]["key2"]["key3"],
2020
 
                                 self.dummy_dbussy.DBUS.ObjectPath)
2021
 
 
2022
 
    def test_call_method_handles_exception(self):
2023
 
        def func():
2024
 
            raise self.dummy_dbussy.DBusError()
2025
 
 
2026
 
        fake_ravel = self.fake_ravel_func(func)
2027
 
        bus = dbussy_adapter.SystemBus(self.dummy_dbussy, fake_ravel)
2028
 
 
2029
 
        with self.assertRaises(dbus.Error) as e:
2030
 
            self.call_method(bus, "methodname", "busname",
2031
 
                             "objectpath", "interface")
2032
 
 
2033
 
        self.assertNotIsInstance(e.exception, dbus.ConnectFailed)
2034
 
 
2035
 
    def test_get_object_converts_to_correct_exception(self):
2036
 
        class fake_ravel_raises_exception_on_connect:
2037
 
            @staticmethod
2038
 
            def system_bus():
2039
 
                class Bus:
2040
 
                    @staticmethod
2041
 
                    def __getitem__(key):
2042
 
                        if key == "objectpath":
2043
 
                            raise self.dummy_dbussy.DBusError()
2044
 
                        raise Exception(key)
2045
 
                return {"busname": Bus()}
2046
 
        def func():
2047
 
            raise self.dummy_dbussy.DBusError()
2048
 
        bus = dbussy_adapter.SystemBus(
2049
 
            self.dummy_dbussy,
2050
 
            fake_ravel_raises_exception_on_connect)
2051
 
        with self.assertRaises(dbus.ConnectFailed):
2052
 
            self.call_method(bus, "methodname", "busname",
2053
 
                             "objectpath", "interface")
2054
 
 
2055
 
 
2056
1777
class Test_commands_from_options(unittest.TestCase):
2057
1778
 
2058
1779
    def setUp(self):