← Back to branch summary

~ubuntu-branches/ubuntu/lucid/landscape-client/lucid-updates

« back to all changes in this revision

Viewing changes to landscape/ui/model/registration/proxy.py

  • Committer: Package Import Robot
  • Author(s): Andreas Hasenack
  • Date: 2012-04-10 14:28:48 UTC
  • mfrom: (1.1.27)
  • mto: This revision was merged to the branch mainline in revision 35.
  • Revision ID: package-import@ubuntu.com-20120410142848-7xsy4g2xii7y7ntc
Import upstream version 12.04.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/ui/model/registration/proxy.py
 
1
import dbus
 
2
 
 
3
import landscape.ui.model.registration.mechanism as mechanism
 
4
 
 
5
 
 
6
class RegistrationProxy(object):
 
7
    """
 
8
    L{RegistrationProxy} allows the use of the L{RegistrationMechanism} via
 
9
    DBus without having to know about DBus.  This in turn allows controller
 
10
    code to remain agnostic to the implementation of registration.
 
11
    """
 
12
 
 
13
    def __init__(self, on_register_notify=None, on_register_error=None,
 
14
                 on_register_succeed=None, on_register_fail=None,
 
15
                 on_disable_succeed=None, on_disable_fail=None, bus=None):
 
16
        self._bus = None
 
17
        self._interface = None
 
18
        self._on_register_notify = on_register_notify
 
19
        self._on_register_error = on_register_error
 
20
        self._on_register_succeed = on_register_succeed
 
21
        self._on_register_fail = on_register_fail
 
22
        self._on_disable_succeed = on_disable_succeed
 
23
        self._on_disable_fail = on_disable_fail
 
24
        self._setup_interface(bus)
 
25
 
 
26
    def _setup_interface(self, bus):
 
27
        """
 
28
        Redefining L{_setup_interface} allows us to bypass DBus for more
 
29
        convenient testing in some instances.
 
30
        """
 
31
        if bus is None:
 
32
            self._bus = dbus.SystemBus()
 
33
        else:
 
34
            self._bus = bus
 
35
        self._remote_object = self._bus.get_object(mechanism.SERVICE_NAME,
 
36
                                                   mechanism.OBJECT_PATH)
 
37
        self._interface = dbus.Interface(self._remote_object,
 
38
                                         mechanism.INTERFACE_NAME)
 
39
 
 
40
    def _exit_handler_wrapper(self, exit_handler):
 
41
 
 
42
        def wrapped_exit_handler(message):
 
43
            self._remove_handlers()
 
44
            exit_handler(message)
 
45
 
 
46
        return wrapped_exit_handler
 
47
 
 
48
    def _register_handlers(self):
 
49
        self._handlers = []
 
50
        if self._on_register_notify:
 
51
            self._handlers.append(
 
52
                self._bus.add_signal_receiver(
 
53
                    self._on_register_notify,
 
54
                    signal_name="register_notify",
 
55
                    dbus_interface=mechanism.INTERFACE_NAME,
 
56
                    bus_name=None,
 
57
                    path=mechanism.OBJECT_PATH))
 
58
        if self._on_register_error:
 
59
            self._handlers.append(
 
60
                self._bus.add_signal_receiver(
 
61
                    self._on_register_error,
 
62
                    signal_name="register_error",
 
63
                    dbus_interface=mechanism.INTERFACE_NAME,
 
64
                    bus_name=None,
 
65
                    path=mechanism.OBJECT_PATH))
 
66
        if self._on_register_succeed:
 
67
            self._handlers.append(
 
68
                self._bus.add_signal_receiver(
 
69
                    self._exit_handler_wrapper(self._on_register_succeed),
 
70
                    signal_name="register_succeed",
 
71
                    dbus_interface=mechanism.INTERFACE_NAME,
 
72
                    bus_name=None,
 
73
                    path=mechanism.OBJECT_PATH))
 
74
        if self._on_register_fail:
 
75
            self._handlers.append(
 
76
                self._bus.add_signal_receiver(
 
77
                    self._exit_handler_wrapper(self._on_register_fail),
 
78
                    signal_name="register_fail",
 
79
                    dbus_interface=mechanism.INTERFACE_NAME,
 
80
                    bus_name=None,
 
81
                    path=mechanism.OBJECT_PATH))
 
82
        if self._on_disable_succeed:
 
83
            self._handlers.append(
 
84
                self._bus.add_signal_receiver(
 
85
                    self._exit_handler_wrapper(self._on_disable_succeed),
 
86
                    signal_name="disable_succeed",
 
87
                    dbus_interface=mechanism.INTERFACE_NAME,
 
88
                    bus_name=None,
 
89
                    path=mechanism.OBJECT_PATH))
 
90
        if self._on_disable_fail:
 
91
            self._handlers.append(
 
92
                self._bus.add_signal_receiver(
 
93
                    self._exit_handler_wrapper(self._on_disable_fail),
 
94
                    signal_name="disable_fail",
 
95
                    dbus_interface=mechanism.INTERFACE_NAME,
 
96
                    bus_name=None,
 
97
                    path=mechanism.OBJECT_PATH))
 
98
 
 
99
    def _remove_handlers(self):
 
100
        for handler in self._handlers:
 
101
            self._bus.remove_signal_receiver(handler)
 
102
 
 
103
    def challenge(self):
 
104
        return self._interface.challenge()
 
105
 
 
106
    def register(self, config_path):
 
107
        self._register_handlers()
 
108
        try:
 
109
            result, message = self._interface.register(config_path)
 
110
        except dbus.DBusException, e:
 
111
            if e.get_dbus_name() != "org.freedesktop.DBus.Error.NoReply":
 
112
                raise
 
113
            else:
 
114
                result = False
 
115
                message = "Registration timed out."
 
116
        if result:
 
117
            self._on_register_succeed()
 
118
        else:
 
119
            self._on_register_error(message)
 
120
        return result
 
121
 
 
122
    def disable(self):
 
123
        self._register_handlers()
 
124
        result = self._interface.disable()
 
125
        if result:
 
126
            self._on_disable_succeed()
 
127
        else:
 
128
            self._on_disable_fail()
 
129
        return result
 
130
 
 
131
    def exit(self):
 
132
        """
 
133
        Cause the mechanism to exit.
 
134
        """
 
135
        try:
 
136
            self._interface.exit()
 
137
        except dbus.DBusException, e:
 
138
            if e.get_dbus_name() != "org.freedesktop.DBus.Error.NoReply":
 
139
                raise