← Back to branch summary

~therve/landscape-client/sysinfo-network-disks

« back to all changes in this revision

Viewing changes to landscape/tests/test_watchdog.py

  • Committer: Christopher Armstrong
  • Date: 2009-03-06 18:15:15 UTC
  • mfrom: (72.1.23 non-root)
  • Revision ID: radix@twistedmatrix.com-20090306181515-ckjxmu2d4nsomk0o
Merge non-root [r=bigkevmcd,niemeyer] [qa=andreas] [f=82159]

It's now possible to run the Landscape client in a non-root mode. This
mode disables the Manager and only runs the Broker, Watchdog, and Monitor.
The README file explains how to set up this mode.

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/tests/test_watchdog.py
19
19
from landscape.watchdog import (
20
20
    Daemon, WatchDog, WatchDogService, ExecutableNotFoundError,
21
21
    WatchDogConfiguration, bootstrap_list,
22
 
    MAXIMUM_CONSECUTIVE_RESTARTS, RESTART_BURST_DELAY, run)
 
22
    MAXIMUM_CONSECUTIVE_RESTARTS, RESTART_BURST_DELAY, run,
 
23
    Broker, Monitor, Manager)
23
24
import landscape.watchdog
24
25
 
25
26
 
41
42
                                                   passthrough=False)
42
43
        self.manager_factory = self.mocker.replace("landscape.watchdog.Manager",
43
44
                                                   passthrough=False)
 
45
 
 
46
    def start_all_daemons(self):
44
47
        self.broker = self.broker_factory(self.bus, verbose=False,
45
48
                                          config=None)
46
49
        self.monitor = self.monitor_factory(self.bus, verbose=False,
57
60
 
58
61
    def test_daemon_construction(self):
59
62
        """The WatchDog sets up some daemons when constructed."""
 
63
        self.start_all_daemons()
60
64
        self.mocker.replay()
61
65
        WatchDog(self.bus)
62
66
 
 
67
    def test_limited_daemon_construction(self):
 
68
        broker = self.broker_factory(self.bus, verbose=False, config=None)
 
69
        monitor = self.monitor_factory(self.bus, verbose=False, config=None)
 
70
        # The manager should *not* be constructed
 
71
        manager = self.manager_factory(ARGS, KWARGS)
 
72
        self.mocker.count(0)
 
73
        self.mocker.replay()
 
74
 
 
75
        WatchDog(self.bus, enabled_daemons=[Broker, Monitor])
 
76
 
 
77
 
63
78
    def test_check_running_one(self):
 
79
        self.start_all_daemons()
64
80
        self.expect(self.broker.is_running()).result(succeed(True))
65
81
        self.expect(self.monitor.is_running()).result(succeed(False))
66
82
        self.expect(self.manager.is_running()).result(succeed(False))
72
88
        return result.addCallback(got_result)
73
89
 
74
90
    def test_check_running_many(self):
 
91
        self.start_all_daemons()
75
92
        self.expect(self.broker.is_running()).result(succeed(True))
76
93
        self.expect(self.monitor.is_running()).result(succeed(True))
77
94
        self.expect(self.manager.is_running()).result(succeed(True))
83
100
                               "landscape-manager"])
84
101
        return result.addCallback(got_result)
85
102
 
 
103
    def test_check_running_limited_daemons(self):
 
104
        """
 
105
        When the user has explicitly asked not to run some daemons, those
 
106
        daemons which are not being run should not checked.
 
107
        """
 
108
        self.broker = self.broker_factory(self.bus, verbose=False,
 
109
                                          config=None)
 
110
        self.expect(self.broker.program).result("landscape-broker")
 
111
        self.expect(self.broker.is_running()).result(succeed(True))
 
112
        self.mocker.replay()
 
113
        result = WatchDog(self.bus, enabled_daemons=[Broker]).check_running()
 
114
        def got_result(r):
 
115
            self.assertEquals(len(r), 1)
 
116
            self.assertEquals(r[0].program, "landscape-broker")
 
117
        return result.addCallback(got_result)
 
118
 
86
119
    def expect_request_exit(self):
87
120
        self.expect(self.broker.request_exit()).result(succeed(False))
88
121
        self.expect(self.broker.wait_or_die()).result(succeed(None))
89
122
        self.expect(self.monitor.wait_or_die()).result(succeed(None))
90
123
        self.expect(self.manager.wait_or_die()).result(succeed(None))
91
124
 
92
 
 
93
125
    def test_start_and_stop_daemons(self):
94
126
        """The WatchDog will start all daemons, starting with the broker."""
 
127
        self.start_all_daemons()
95
128
        self.mocker.order()
96
129
 
97
130
        self.broker.start()
108
141
        clock.advance(0)
109
142
        return dog.request_exit()
110
143
 
 
144
    def test_start_limited_daemons(self):
 
145
        """
 
146
        start only starts the daemons which are actually enabled.
 
147
        """
 
148
        self.broker = self.broker_factory(self.bus, verbose=False,
 
149
                                          config=None)
 
150
        self.expect(self.broker.program).result("landscape-broker")
 
151
        self.mocker.count(0, None)
 
152
        self.broker.start()
 
153
 
 
154
        self.mocker.replay()
 
155
 
 
156
        clock = Clock()
 
157
        dog = WatchDog(self.bus, clock, enabled_daemons=[Broker])
 
158
        dog.start()
 
159
 
111
160
    def test_request_exit(self):
112
161
        """request_exit() asks the broker to exit.
113
162
 
116
165
        When the deferred returned from request_exit fires, the process should
117
166
        definitely be gone.
118
167
        """
 
168
        self.start_all_daemons()
119
169
        self.expect_request_exit()
120
170
        self.mocker.replay()
121
171
        return WatchDog(self.bus).request_exit()
125
175
        When request_exit occurs between a ping request and response, a failing
126
176
        ping response should not cause the process to be restarted.
127
177
        """
 
178
        self.start_all_daemons()
128
179
        self.mocker.order()
129
180
 
130
181
        self.broker.start()
864
915
        self.config.load([])
865
916
        self.assertEquals(self.config.pid_file, None)
866
917
 
 
918
    def test_monitor_only(self):
 
919
        self.config.load(["--monitor-only"])
 
920
        self.assertEquals(self.config.get_enabled_daemons(),
 
921
                          [Broker, Monitor])
 
922
 
 
923
    def test_default_daemons(self):
 
924
        self.config.load([])
 
925
        self.assertEquals(self.config.get_enabled_daemons(),
 
926
                          [Broker, Monitor, Manager])
 
927
 
867
928
 
868
929
class WatchDogServiceTest(LandscapeTest):
869
930
 
953
1014
        self.assertFalse(os.path.exists(pid_file))
954
1015
 
955
1016
    def test_remove_pid_file(self):
 
1017
        """
 
1018
        When the service is stopped, the pid file is removed.
 
1019
        """
956
1020
        #don't really daemonize or request an exit
957
1021
        daemonize = self.mocker.replace("landscape.watchdog.daemonize",
958
1022
                                        passthrough=False)
959
 
        watchdog = self.mocker.patch(WatchDog)
 
1023
        watchdog_factory = self.mocker.replace("landscape.watchdog.WatchDog",
 
1024
                                               passthrough=False)
 
1025
        watchdog = watchdog_factory(ARGS, KWARGS)
 
1026
        watchdog.start()
 
1027
        self.mocker.result(succeed(None))
960
1028
 
961
1029
        watchdog.check_running()
962
1030
        self.mocker.result(succeed([]))
1193
1261
"""
1194
1262
 
1195
1263
 
 
1264
class FakeReactor(Clock):
 
1265
    running = False
 
1266
    def run(self):
 
1267
        self.running = True
 
1268
 
 
1269
 
1196
1270
class WatchDogRunTests(LandscapeTest):
1197
1271
    def setUp(self):
1198
1272
        super(WatchDogRunTests, self).setUp()
1202
1276
        WatchDogConfiguration.default_config_filenames = []
1203
1277
 
1204
1278
    def test_non_root(self):
 
1279
        """
 
1280
        The watchdog should print an error message and exit if run by a normal
 
1281
        user.
 
1282
        """
1205
1283
        self.mocker.replace("os.getuid")()
 
1284
        self.mocker.count(1, None)
1206
1285
        self.mocker.result(1000)
1207
1286
        self.mocker.replay()
1208
1287
        sys_exit = self.assertRaises(SystemExit, run, ["--bus", "system"])
1209
1288
        self.assertIn("landscape-client must be run as root", str(sys_exit))
 
1289
 
 
1290
    def test_landscape_user(self):
 
1291
        """
 
1292
        The watchdog *can* be run as the 'landscape' user.
 
1293
        """
 
1294
        pwinfo = self.mocker.replace("pwd.getpwnam")("landscape")
 
1295
        self.expect(pwinfo.pw_uid).result(os.getuid())
 
1296
        self.mocker.replay()
 
1297
        reactor = FakeReactor()
 
1298
        run(["--bus", "system", "--log-dir", self.make_path()],
 
1299
            reactor=reactor)
 
1300
        self.assertTrue(reactor.running)
 
1301