1
=== modified file 'src/provisioningserver/boot/tests/test_powernv.py'
2
--- src/provisioningserver/boot/tests/test_powernv.py	2014-08-13 21:49:35 +0000
3
+++ src/provisioningserver/boot/tests/test_powernv.py	2014-08-27 06:01:25 +0000
4
@@ -31,9 +31,9 @@
5
31
    )
31
    )
6
32
from provisioningserver.boot.tests.test_pxe import parse_pxe_config
32
from provisioningserver.boot.tests.test_pxe import parse_pxe_config
7
33
from provisioningserver.boot.tftppath import compose_image_path
33
from provisioningserver.boot.tftppath import compose_image_path
8
34
from provisioningserver.pserv_services.tftp import TFTPBackend
9
34
from provisioningserver.testing.config import set_tftp_root
35
from provisioningserver.testing.config import set_tftp_root
10
35
from provisioningserver.tests.test_kernel_opts import make_kernel_parameters
36
from provisioningserver.tests.test_kernel_opts import make_kernel_parameters
11
36
from provisioningserver.tftp import TFTPBackend
12
37
from testtools.matchers import (
37
from testtools.matchers import (
13
38
    IsInstance,
38
    IsInstance,
14
39
    MatchesAll,
39
    MatchesAll,
15
40
40
16
=== modified file 'src/provisioningserver/plugin.py'
17
--- src/provisioningserver/plugin.py	2014-08-26 23:55:04 +0000
18
+++ src/provisioningserver/plugin.py	2014-08-27 06:01:25 +0000
19
@@ -31,10 +31,14 @@
20
31
import provisioningserver
31
import provisioningserver
21
32
from provisioningserver.cluster_config import get_cluster_uuid
32
from provisioningserver.cluster_config import get_cluster_uuid
22
33
from provisioningserver.config import Config
33
from provisioningserver.config import Config
24
34
from provisioningserver.rpc.boot_images import PeriodicImageDownloadService
34
from provisioningserver.pserv_services.image_download_service import (
25
35
    PeriodicImageDownloadService,
26
36
    )
27
37
from provisioningserver.pserv_services.node_power_monitor_service import (
28
38
    NodePowerMonitorService,
29
39
    )
30
40
from provisioningserver.pserv_services.tftp import TFTPService
31
35
from provisioningserver.rpc.clusterservice import ClusterClientService
41
from provisioningserver.rpc.clusterservice import ClusterClientService
32
36
from provisioningserver.rpc.power import NodePowerMonitorService
33
37
from provisioningserver.tftp import TFTPService
34
38
from twisted.application.internet import TCPServer
42
from twisted.application.internet import TCPServer
35
39
from twisted.application.service import (
43
from twisted.application.service import (
36
40
    IServiceMaker,
44
    IServiceMaker,
37
41
45
38
=== added directory 'src/provisioningserver/pserv_services'
39
=== added file 'src/provisioningserver/pserv_services/__init__.py'
40
=== added file 'src/provisioningserver/pserv_services/image_download_service.py'
41
--- src/provisioningserver/pserv_services/image_download_service.py	1970-01-01 00:00:00 +0000
42
+++ src/provisioningserver/pserv_services/image_download_service.py	2014-08-27 06:01:25 +0000
43
@@ -0,0 +1,120 @@
44
1
# Copyright 2014 Canonical Ltd.  This software is licensed under the
45
2
# GNU Affero General Public License version 3 (see the file LICENSE).
46
3
47
4
"""Service to periodically refresh the boot images."""
48
5
49
6
from __future__ import (
50
7
    absolute_import,
51
8
    print_function,
52
9
    unicode_literals,
53
10
    )
54
11
55
12
str = None
56
13
57
14
__metaclass__ = type
58
15
__all__ = [
59
16
    "PeriodicImageDownloadService",
60
17
    ]
61
18
62
19
63
20
from datetime import timedelta
64
21
65
22
from provisioningserver.boot import tftppath
66
23
from provisioningserver.logger import get_maas_logger
67
24
from provisioningserver.rpc.boot_images import import_boot_images
68
25
from provisioningserver.rpc.exceptions import NoConnectionsAvailable
69
26
from provisioningserver.rpc.region import (
70
27
    GetBootSources,
71
28
    GetBootSourcesV2,
72
29
    )
73
30
from provisioningserver.utils.twisted import pause
74
31
from twisted.application.internet import TimerService
75
32
from twisted.internet.defer import (
76
33
    DeferredLock,
77
34
    inlineCallbacks,
78
35
    returnValue,
79
36
    )
80
37
from twisted.spread.pb import NoSuchMethod
81
38
82
39
83
40
maaslog = get_maas_logger("boot_image_download_service")
84
41
service_lock = DeferredLock()
85
42
86
43
87
44
class PeriodicImageDownloadService(TimerService, object):
88
45
    """Twisted service to periodically refresh ephemeral images.
89
46
90
47
    :param client_service: A `ClusterClientService` instance for talking
91
48
        to the region controller.
92
49
    :param reactor: An `IReactor` instance.
93
50
    """
94
51
95
52
    check_interval = timedelta(minutes=5).total_seconds()
96
53
97
54
    def __init__(self, client_service, reactor, cluster_uuid):
98
55
        # Call self.check() every self.check_interval.
99
56
        super(PeriodicImageDownloadService, self).__init__(
100
57
            self.check_interval, self.maybe_start_download)
101
58
        self.clock = reactor
102
59
        self.client_service = client_service
103
60
        self.uuid = cluster_uuid
104
61
105
62
    @inlineCallbacks
106
63
    def _get_boot_sources(self, client):
107
64
        """Gets the boot sources from the region."""
108
65
        try:
109
66
            sources = yield client(GetBootSourcesV2, uuid=self.uuid)
110
67
        except NoSuchMethod:
111
68
            # Region has not been upgraded to support the new call, use the
112
69
            # old call. The old call did not provide the new os selection
113
70
            # parameter. Region does not support boot source selection by os,
114
71
            # so its set too allow all operating systems.
115
72
            sources = yield client(GetBootSources, uuid=self.uuid)
116
73
            for source in sources['sources']:
117
74
                for selection in source['selections']:
118
75
                    selection['os'] = '*'
119
76
        returnValue(sources)
120
77
121
78
    @inlineCallbacks
122
79
    def _start_download(self):
123
80
        client = None
124
81
        # Retry a few times, since this service usually comes up before
125
82
        # the RPC service.
126
83
        for _ in range(3):
127
84
            try:
128
85
                client = self.client_service.getClient()
129
86
                break
130
87
            except NoConnectionsAvailable:
131
88
                yield pause(5)
132
89
        if client is None:
133
90
            maaslog.error(
134
91
                "Can't initiate image download, no RPC connection to region.")
135
92
            return
136
93
137
94
        # Get sources from region
138
95
        sources = yield self._get_boot_sources(client)
139
96
        yield import_boot_images(sources.get("sources"))
140
97
141
98
    @inlineCallbacks
142
99
    def maybe_start_download(self):
143
100
        """Check the time the last image refresh happened and initiate a new
144
101
        one if older than 15 minutes.
145
102
        """
146
103
        # Use a DeferredLock to prevent simultaneous downloads.
147
104
        if service_lock.locked:
148
105
            # Don't want to block on lock release.
149
106
            return
150
107
        yield service_lock.acquire()
151
108
        try:
152
109
            last_modified = tftppath.maas_meta_last_modified()
153
110
            if last_modified is None:
154
111
                # Don't auto-refresh if the user has never manually initiated
155
112
                # a download.
156
113
                return
157
114
158
115
            age_in_seconds = self.clock.seconds() - last_modified
159
116
            if age_in_seconds >= timedelta(minutes=15).total_seconds():
160
117
                yield self._start_download()
161
118
162
119
        finally:
163
120
            service_lock.release()
164
0
121
165
=== added file 'src/provisioningserver/pserv_services/node_power_monitor_service.py'
166
--- src/provisioningserver/pserv_services/node_power_monitor_service.py	1970-01-01 00:00:00 +0000
167
+++ src/provisioningserver/pserv_services/node_power_monitor_service.py	2014-08-27 06:01:25 +0000
168
@@ -0,0 +1,75 @@
169
1
# Copyright 2014 Canonical Ltd.  This software is licensed under the
170
2
# GNU Affero General Public License version 3 (see the file LICENSE).
171
3
172
4
"""Service to periodically query the power state on this cluster's nodes."""
173
5
174
6
175
7
from __future__ import (
176
8
    absolute_import,
177
9
    print_function,
178
10
    unicode_literals,
179
11
    )
180
12
181
13
str = None
182
14
183
15
__metaclass__ = type
184
16
__all__ = [
185
17
    "NodePowerMonitorService"
186
18
]
187
19
188
20
189
21
from provisioningserver.logger.log import get_maas_logger
190
22
from provisioningserver.rpc.exceptions import NoConnectionsAvailable
191
23
from provisioningserver.rpc.power import query_all_nodes
192
24
from provisioningserver.rpc.region import ListNodePowerParameters
193
25
from provisioningserver.utils.twisted import pause
194
26
from twisted.application.internet import TimerService
195
27
from twisted.internet.defer import inlineCallbacks
196
28
197
29
198
30
maaslog = get_maas_logger("power_monitor_service")
199
31
200
32
201
33
class NodePowerMonitorService(TimerService, object):
202
34
    """Twisted service to monitor the status of all nodes
203
35
    controlled by this cluster.
204
36
205
37
    :param client_service: A `ClusterClientService` instance for talking
206
38
        to the region controller.
207
39
    :param reactor: An `IReactor` instance.
208
40
    """
209
41
210
42
    # XXX 2014-08-27 bug=1361967
211
43
    # This service is COMPLETELY UNTESTED.
212
44
213
45
    check_interval = 600  # 5 minutes.
214
46
215
47
    def __init__(self, client_service, reactor, cluster_uuid):
216
48
        # Call self.check() every self.check_interval.
217
49
        super(NodePowerMonitorService, self).__init__(
218
50
            self.check_interval, self.query_nodes)
219
51
        self.clock = reactor
220
52
        self.client_service = client_service
221
53
        self.uuid = cluster_uuid
222
54
223
55
    @inlineCallbacks
224
56
    def query_nodes(self):
225
57
        client = None
226
58
        # Retry a few times, since this service usually comes up before
227
59
        # the RPC service.
228
60
        for _ in range(3):
229
61
            try:
230
62
                client = self.client_service.getClient()
231
63
                break
232
64
            except NoConnectionsAvailable:
233
65
                yield pause(5)
234
66
        if client is None:
235
67
            maaslog.error(
236
68
                "Can't query nodes's BMC for power state, no RPC connection "
237
69
                "to region.")
238
70
            return
239
71
240
72
        # Get the nodes from the Region
241
73
        response = yield client(ListNodePowerParameters, uuid=self.uuid)
242
74
        nodes = response['nodes']
243
75
        yield query_all_nodes(nodes)
244
0
76
245
=== added directory 'src/provisioningserver/pserv_services/tests'
246
=== added file 'src/provisioningserver/pserv_services/tests/__init__.py'
247
=== added file 'src/provisioningserver/pserv_services/tests/test_image_download_service.py'
248
--- src/provisioningserver/pserv_services/tests/test_image_download_service.py	1970-01-01 00:00:00 +0000
249
+++ src/provisioningserver/pserv_services/tests/test_image_download_service.py	2014-08-27 06:01:25 +0000
250
@@ -0,0 +1,279 @@
251
1
# Copyright 2014 Canonical Ltd.  This software is licensed under the
252
2
# GNU Affero General Public License version 3 (see the file LICENSE).
253
3
254
4
"""Tests for provisioningserver.pserv_services.image_download_service"""
255
5
256
6
from __future__ import (
257
7
    absolute_import,
258
8
    print_function,
259
9
    unicode_literals,
260
10
    )
261
11
262
12
str = None
263
13
264
14
__metaclass__ = type
265
15
__all__ = []
266
16
267
17
268
18
from datetime import timedelta
269
19
270
20
from maastesting.factory import factory
271
21
from maastesting.matchers import (
272
22
    get_mock_calls,
273
23
    MockCalledOnceWith,
274
24
    MockCallsMatch,
275
25
    MockNotCalled,
276
26
    )
277
27
from mock import (
278
28
    call,
279
29
    Mock,
280
30
    sentinel,
281
31
    )
282
32
from provisioningserver.boot import tftppath
283
33
from provisioningserver.pserv_services.image_download_service import (
284
34
    PeriodicImageDownloadService,
285
35
    service_lock,
286
36
    )
287
37
from provisioningserver.rpc import boot_images
288
38
from provisioningserver.rpc.boot_images import _run_import
289
39
from provisioningserver.rpc.exceptions import NoConnectionsAvailable
290
40
from provisioningserver.rpc.region import (
291
41
    GetBootSources,
292
42
    GetBootSourcesV2,
293
43
    )
294
44
from provisioningserver.testing.testcase import PservTestCase
295
45
from provisioningserver.utils.twisted import pause
296
46
from testtools.deferredruntest import AsynchronousDeferredRunTest
297
47
from twisted.application.internet import TimerService
298
48
from twisted.internet import defer
299
49
from twisted.internet.task import Clock
300
50
from twisted.spread.pb import NoSuchMethod
301
51
302
52
303
53
class TestPeriodicImageDownloadService(PservTestCase):
304
54
305
55
    run_tests_with = AsynchronousDeferredRunTest.make_factory(timeout=5)
306
56
307
57
    def test_init(self):
308
58
        service = PeriodicImageDownloadService(
309
59
            sentinel.service, sentinel.clock, sentinel.uuid)
310
60
        self.assertIsInstance(service, TimerService)
311
61
        self.assertIs(service.clock, sentinel.clock)
312
62
        self.assertIs(service.uuid, sentinel.uuid)
313
63
        self.assertIs(service.client_service, sentinel.service)
314
64
315
65
    def patch_download(self, service, return_value):
316
66
        patched = self.patch(service, '_start_download')
317
67
        patched.return_value = defer.succeed(return_value)
318
68
        return patched
319
69
320
70
    def test_is_called_every_interval(self):
321
71
        clock = Clock()
322
72
        service = PeriodicImageDownloadService(
323
73
            sentinel.service, clock, sentinel.uuid)
324
74
        # Avoid actual downloads:
325
75
        self.patch_download(service, None)
326
76
        maas_meta_last_modified = self.patch(
327
77
            tftppath, 'maas_meta_last_modified')
328
78
        maas_meta_last_modified.return_value = None
329
79
        service.startService()
330
80
331
81
        # The first call is issued at startup.
332
82
        self.assertEqual(1, len(get_mock_calls(maas_meta_last_modified)))
333
83
334
84
        # Wind clock forward one second less than the desired interval.
335
85
        clock.advance(service.check_interval - 1)
336
86
        # No more periodic calls made.
337
87
        self.assertEqual(1, len(get_mock_calls(maas_meta_last_modified)))
338
88
339
89
        # Wind clock forward one second, past the interval.
340
90
        clock.advance(1)
341
91
342
92
        # Now there were two calls.
343
93
        self.assertEqual(2, len(get_mock_calls(maas_meta_last_modified)))
344
94
345
95
        # Forward another interval, should be three calls.
346
96
        clock.advance(service.check_interval)
347
97
        self.assertEqual(3, len(get_mock_calls(maas_meta_last_modified)))
348
98
349
99
    def test_no_download_if_no_meta_file(self):
350
100
        clock = Clock()
351
101
        service = PeriodicImageDownloadService(
352
102
            sentinel.service, clock, sentinel.uuid)
353
103
        _start_download = self.patch_download(service, None)
354
104
        self.patch(
355
105
            tftppath,
356
106
            'maas_meta_last_modified').return_value = None
357
107
        service.startService()
358
108
        self.assertThat(_start_download, MockNotCalled())
359
109
360
110
    def test_initiates_download_if_15_minutes_has_passed(self):
361
111
        clock = Clock()
362
112
        service = PeriodicImageDownloadService(
363
113
            sentinel.service, clock, sentinel.uuid)
364
114
        _start_download = self.patch_download(service, None)
365
115
        one_week_ago = clock.seconds() - timedelta(minutes=15).total_seconds()
366
116
        self.patch(
367
117
            tftppath,
368
118
            'maas_meta_last_modified').return_value = one_week_ago
369
119
        service.startService()
370
120
        self.assertThat(_start_download, MockCalledOnceWith())
371
121
372
122
    def test_no_download_if_15_minutes_has_not_passed(self):
373
123
        clock = Clock()
374
124
        service = PeriodicImageDownloadService(
375
125
            sentinel.service, clock, sentinel.uuid)
376
126
        _start_download = self.patch_download(service, None)
377
127
        one_week = timedelta(minutes=15).total_seconds()
378
128
        self.patch(
379
129
            tftppath,
380
130
            'maas_meta_last_modified').return_value = clock.seconds()
381
131
        clock.advance(one_week - 1)
382
132
        service.startService()
383
133
        self.assertThat(_start_download, MockNotCalled())
384
134
385
135
    def test_download_is_initiated_in_new_thread(self):
386
136
        clock = Clock()
387
137
        maas_meta_last_modified = self.patch(
388
138
            tftppath, 'maas_meta_last_modified')
389
139
        one_week = timedelta(minutes=15).total_seconds()
390
140
        maas_meta_last_modified.return_value = clock.seconds() - one_week
391
141
        rpc_client = Mock()
392
142
        client_call = Mock()
393
143
        client_call.side_effect = [
394
144
            defer.succeed(dict(sources=sentinel.sources)),
395
145
            ]
396
146
        rpc_client.getClient.return_value = client_call
397
147
398
148
        # We could patch out 'import_boot_images' instead here but I
399
149
        # don't do that for 2 reasons:
400
150
        # 1. It requires spinning the reactor again before being able to
401
151
        # test the result.
402
152
        # 2. It means there's no thread to clean up after the test.
403
153
        deferToThread = self.patch(boot_images, 'deferToThread')
404
154
        deferToThread.return_value = defer.succeed(None)
405
155
        service = PeriodicImageDownloadService(
406
156
            rpc_client, clock, sentinel.uuid)
407
157
        service.startService()
408
158
        self.assertThat(
409
159
            deferToThread, MockCalledOnceWith(
410
160
                _run_import, sentinel.sources))
411
161
412
162
    def test_no_download_if_no_rpc_connections(self):
413
163
        rpc_client = Mock()
414
164
        failure = NoConnectionsAvailable()
415
165
        rpc_client.getClient.return_value.side_effect = failure
416
166
417
167
        deferToThread = self.patch(boot_images, 'deferToThread')
418
168
        service = PeriodicImageDownloadService(
419
169
            rpc_client, Clock(), sentinel.uuid)
420
170
        service.startService()
421
171
        self.assertThat(deferToThread, MockNotCalled())
422
172
423
173
    @defer.inlineCallbacks
424
174
    def test_does_not_run_if_lock_taken(self):
425
175
        maas_meta_last_modified = self.patch(
426
176
            tftppath, 'maas_meta_last_modified')
427
177
        yield service_lock.acquire()
428
178
        self.addCleanup(service_lock.release)
429
179
        service = PeriodicImageDownloadService(
430
180
            sentinel.rpc, Clock(), sentinel.uuid)
431
181
        service.startService()
432
182
        self.assertThat(maas_meta_last_modified, MockNotCalled())
433
183
434
184
    def test_takes_lock_when_running(self):
435
185
        clock = Clock()
436
186
        service = PeriodicImageDownloadService(
437
187
            sentinel.rpc, clock, sentinel.uuid)
438
188
439
189
        # Patch the download func so it's just a Deferred that waits for
440
190
        # one second.
441
191
        _start_download = self.patch(service, '_start_download')
442
192
        _start_download.return_value = pause(1, clock)
443
193
444
194
        # Set conditions for a required download:
445
195
        one_week_ago = clock.seconds() - timedelta(minutes=15).total_seconds()
446
196
        self.patch(
447
197
            tftppath,
448
198
            'maas_meta_last_modified').return_value = one_week_ago
449
199
450
200
        # Lock is acquired for the first download after startup.
451
201
        service.startService()
452
202
        self.assertTrue(service_lock.locked)
453
203
454
204
        # Lock is released once the download is done.
455
205
        clock.advance(1)
456
206
        self.assertFalse(service_lock.locked)
457
207
458
208
    @defer.inlineCallbacks
459
209
    def test__get_boot_sources_calls_get_boot_sources_v2_before_v1(self):
460
210
        clock = Clock()
461
211
        client_call = Mock()
462
212
        client_call.side_effect = [
463
213
            defer.succeed(dict(sources=sentinel.sources)),
464
214
            ]
465
215
466
216
        service = PeriodicImageDownloadService(
467
217
            sentinel.rpc, clock, sentinel.uuid)
468
218
        sources = yield service._get_boot_sources(client_call)
469
219
        self.assertEqual(sources.get('sources'), sentinel.sources)
470
220
        self.assertThat(
471
221
            client_call,
472
222
            MockCalledOnceWith(GetBootSourcesV2, uuid=sentinel.uuid))
473
223
474
224
    @defer.inlineCallbacks
475
225
    def test__get_boot_sources_calls_get_boot_sources_v1_on_v2_missing(self):
476
226
        clock = Clock()
477
227
        client_call = Mock()
478
228
        client_call.side_effect = [
479
229
            defer.fail(NoSuchMethod()),
480
230
            defer.succeed(dict(sources=[])),
481
231
            ]
482
232
483
233
        service = PeriodicImageDownloadService(
484
234
            sentinel.rpc, clock, sentinel.uuid)
485
235
        yield service._get_boot_sources(client_call)
486
236
        self.assertThat(
487
237
            client_call,
488
238
            MockCallsMatch(
489
239
                call(GetBootSourcesV2, uuid=sentinel.uuid),
490
240
                call(GetBootSources, uuid=sentinel.uuid)))
491
241
492
242
    @defer.inlineCallbacks
493
243
    def test__get_boot_sources_v1_sets_os_to_wildcard(self):
494
244
        sources = [
495
245
            {
496
246
                'path': factory.make_url(),
497
247
                'selections': [
498
248
                    {
499
249
                        'release': "trusty",
500
250
                        'arches': ["amd64"],
501
251
                        'subarches': ["generic"],
502
252
                        'labels': ["release"],
503
253
                    },
504
254
                    {
505
255
                        'release': "precise",
506
256
                        'arches': ["amd64"],
507
257
                        'subarches': ["generic"],
508
258
                        'labels': ["release"],
509
259
                    },
510
260
                ],
511
261
            },
512
262
        ]
513
263
514
264
        clock = Clock()
515
265
        client_call = Mock()
516
266
        client_call.side_effect = [
517
267
            defer.fail(NoSuchMethod()),
518
268
            defer.succeed(dict(sources=sources)),
519
269
            ]
520
270
521
271
        service = PeriodicImageDownloadService(
522
272
            sentinel.rpc, clock, sentinel.uuid)
523
273
        sources = yield service._get_boot_sources(client_call)
524
274
        os_selections = [
525
275
            selection.get('os')
526
276
            for source in sources['sources']
527
277
            for selection in source['selections']
528
278
            ]
529
279
        self.assertEqual(['*', '*'], os_selections)
530
0
280
531
=== renamed file 'src/provisioningserver/tftp.py' => 'src/provisioningserver/pserv_services/tftp.py'
532
=== modified file 'src/provisioningserver/rpc/boot_images.py'
533
--- src/provisioningserver/rpc/boot_images.py	2014-08-26 17:23:16 +0000
534
+++ src/provisioningserver/rpc/boot_images.py	2014-08-27 06:01:25 +0000
535
@@ -15,39 +15,17 @@
536
15
__all__ = [
15
__all__ = [
537
16
    "import_boot_images",
16
    "import_boot_images",
538
17
    "list_boot_images",
17
    "list_boot_images",
539
18
    "PeriodicImageDownloadService",
540
19
    ]
18
    ]
541
20
19
542
21
20
543
22
from datetime import timedelta
544
23
545
24
from provisioningserver.auth import MAAS_USER_GPGHOME
21
from provisioningserver.auth import MAAS_USER_GPGHOME
546
25
from provisioningserver.boot import tftppath
22
from provisioningserver.boot import tftppath
547
26
from provisioningserver.config import Config
23
from provisioningserver.config import Config
548
27
from provisioningserver.import_images import boot_resources
24
from provisioningserver.import_images import boot_resources
549
28
from provisioningserver.logger import get_maas_logger
550
29
from provisioningserver.rpc.exceptions import NoConnectionsAvailable
551
30
from provisioningserver.rpc.region import (
552
31
    GetBootSources,
553
32
    GetBootSourcesV2,
554
33
    )
555
34
from provisioningserver.utils.env import environment_variables
25
from provisioningserver.utils.env import environment_variables
566
35
from provisioningserver.utils.twisted import (
26
from provisioningserver.utils.twisted import synchronous
567
36
    pause,
27
from twisted.internet.defer import inlineCallbacks
558
37
    synchronous,
559
38
    )
560
39
from twisted.application.internet import TimerService
561
40
from twisted.internet.defer import (
562
41
    DeferredLock,
563
42
    inlineCallbacks,
564
43
    returnValue,
565
44
    )
568
45
from twisted.internet.threads import deferToThread
28
from twisted.internet.threads import deferToThread
569
46
from twisted.spread.pb import NoSuchMethod
570
47
571
48
572
49
maaslog = get_maas_logger("boot_images")
573
50
service_lock = DeferredLock()
574
51
29
575
52
30
576
53
def list_boot_images():
31
def list_boot_images():
577
@@ -73,82 +51,3 @@
578
73
def import_boot_images(sources):
51
def import_boot_images(sources):
579
74
    """Imports the boot images from the given sources."""
52
    """Imports the boot images from the given sources."""
580
75
    yield deferToThread(_run_import, sources)
53
    yield deferToThread(_run_import, sources)
581
76
582
77
583
78
class PeriodicImageDownloadService(TimerService, object):
584
79
    """Twisted service to periodically refresh ephemeral images.
585
80
586
81
    :param client_service: A `ClusterClientService` instance for talking
587
82
        to the region controller.
588
83
    :param reactor: An `IReactor` instance.
589
84
    """
590
85
591
86
    check_interval = timedelta(minutes=5).total_seconds()
592
87
593
88
    def __init__(self, client_service, reactor, cluster_uuid):
594
89
        # Call self.check() every self.check_interval.
595
90
        super(PeriodicImageDownloadService, self).__init__(
596
91
            self.check_interval, self.maybe_start_download)
597
92
        self.clock = reactor
598
93
        self.client_service = client_service
599
94
        self.uuid = cluster_uuid
600
95
601
96
    @inlineCallbacks
602
97
    def _get_boot_sources(self, client):
603
98
        """Gets the boot sources from the region."""
604
99
        try:
605
100
            sources = yield client(GetBootSourcesV2, uuid=self.uuid)
606
101
        except NoSuchMethod:
607
102
            # Region has not been upgraded to support the new call, use the
608
103
            # old call. The old call did not provide the new os selection
609
104
            # parameter. Region does not support boot source selection by os,
610
105
            # so its set too allow all operating systems.
611
106
            sources = yield client(GetBootSources, uuid=self.uuid)
612
107
            for source in sources['sources']:
613
108
                for selection in source['selections']:
614
109
                    selection['os'] = '*'
615
110
        returnValue(sources)
616
111
617
112
    @inlineCallbacks
618
113
    def _start_download(self):
619
114
        client = None
620
115
        # Retry a few times, since this service usually comes up before
621
116
        # the RPC service.
622
117
        for _ in range(3):
623
118
            try:
624
119
                client = self.client_service.getClient()
625
120
                break
626
121
            except NoConnectionsAvailable:
627
122
                yield pause(5)
628
123
        if client is None:
629
124
            maaslog.error(
630
125
                "Can't initiate image download, no RPC connection to region.")
631
126
            return
632
127
633
128
        # Get sources from region
634
129
        sources = yield self._get_boot_sources(client)
635
130
        yield import_boot_images(sources.get("sources"))
636
131
637
132
    @inlineCallbacks
638
133
    def maybe_start_download(self):
639
134
        """Check the time the last image refresh happened and initiate a new
640
135
        one if older than 15 minutes.
641
136
        """
642
137
        # Use a DeferredLock to prevent simultaneous downloads.
643
138
        if service_lock.locked:
644
139
            # Don't want to block on lock release.
645
140
            return
646
141
        yield service_lock.acquire()
647
142
        try:
648
143
            last_modified = tftppath.maas_meta_last_modified()
649
144
            if last_modified is None:
650
145
                # Don't auto-refresh if the user has never manually initiated
651
146
                # a download.
652
147
                return
653
148
654
149
            age_in_seconds = self.clock.seconds() - last_modified
655
150
            if age_in_seconds >= timedelta(minutes=15).total_seconds():
656
151
                yield self._start_download()
657
152
658
153
        finally:
659
154
            service_lock.release()
660
155
54
661
=== modified file 'src/provisioningserver/rpc/power.py'
662
--- src/provisioningserver/rpc/power.py	2014-08-22 16:49:23 +0000
663
+++ src/provisioningserver/rpc/power.py	2014-08-27 06:01:25 +0000
664
@@ -13,7 +13,8 @@
665
13
13
666
14
__metaclass__ = type
14
__metaclass__ = type
667
15
__all__ = [
15
__all__ = [
669
16
    "get_power_state"
16
    "get_power_state",
670
17
    "query_all_nodes",
671
17
]
18
]
672
18
19
673
19
20
674
@@ -27,17 +28,12 @@
675
27
    PowerActionFail,
28
    PowerActionFail,
676
28
    )
29
    )
677
29
from provisioningserver.rpc import getRegionClient
30
from provisioningserver.rpc import getRegionClient
682
30
from provisioningserver.rpc.exceptions import (
31
from provisioningserver.rpc.exceptions import NoSuchNode
679
31
    NoConnectionsAvailable,
680
32
    NoSuchNode,
681
33
    )
683
34
from provisioningserver.rpc.region import (
32
from provisioningserver.rpc.region import (
684
35
    ListNodePowerParameters,
685
36
    MarkNodeBroken,
33
    MarkNodeBroken,
686
37
    UpdateNodePowerState,
34
    UpdateNodePowerState,
687
38
    )
35
    )
688
39
from provisioningserver.utils.twisted import pause
36
from provisioningserver.utils.twisted import pause
689
40
from twisted.application.internet import TimerService
690
41
from twisted.internet import reactor
37
from twisted.internet import reactor
691
42
from twisted.internet.defer import (
38
from twisted.internet.defer import (
692
43
    inlineCallbacks,
39
    inlineCallbacks,
693
@@ -256,45 +252,3 @@
694
256
                maaslog.debug(
252
                maaslog.debug(
695
257
                    "%s: Could not update power status; "
253
                    "%s: Could not update power status; "
696
258
                    "no such node.", hostname)
254
                    "no such node.", hostname)
697
259
698
260
699
261
class NodePowerMonitorService(TimerService, object):
700
262
    """Twisted service to monitor the status of all nodes
701
263
    controlled by this cluster.
702
264
703
265
    :param client_service: A `ClusterClientService` instance for talking
704
266
        to the region controller.
705
267
    :param reactor: An `IReactor` instance.
706
268
    """
707
269
708
270
    check_interval = 600  # 5 minutes.
709
271
710
272
    def __init__(self, client_service, reactor, cluster_uuid):
711
273
        # Call self.check() every self.check_interval.
712
274
        super(NodePowerMonitorService, self).__init__(
713
275
            self.check_interval, self.query_nodes)
714
276
        self.clock = reactor
715
277
        self.client_service = client_service
716
278
        self.uuid = cluster_uuid
717
279
718
280
    @inlineCallbacks
719
281
    def query_nodes(self):
720
282
        client = None
721
283
        # Retry a few times, since this service usually comes up before
722
284
        # the RPC service.
723
285
        for _ in range(3):
724
286
            try:
725
287
                client = self.client_service.getClient()
726
288
                break
727
289
            except NoConnectionsAvailable:
728
290
                yield pause(5)
729
291
        if client is None:
730
292
            maaslog.error(
731
293
                "Can't query nodes's BMC for power state, no RPC connection "
732
294
                "to region.")
733
295
            return
734
296
735
297
        # Get the nodes from the Region
736
298
        response = yield client(ListNodePowerParameters, uuid=self.uuid)
737
299
        nodes = response['nodes']
738
300
        yield query_all_nodes(nodes)
739
301
255
740
=== modified file 'src/provisioningserver/rpc/tests/test_boot_images.py'
741
--- src/provisioningserver/rpc/tests/test_boot_images.py	2014-08-26 17:23:16 +0000
742
+++ src/provisioningserver/rpc/tests/test_boot_images.py	2014-08-27 06:01:25 +0000
743
@@ -14,21 +14,11 @@
744
14
__metaclass__ = type
14
__metaclass__ = type
745
15
__all__ = []
15
__all__ = []
746
16
16
747
17
from datetime import timedelta
748
18
import os
17
import os
749
19
18
750
20
from maastesting.factory import factory
19
from maastesting.factory import factory
762
21
from maastesting.matchers import (
20
from maastesting.matchers import MockCalledOnceWith
763
22
    get_mock_calls,
21
from mock import sentinel
753
23
    MockCalledOnceWith,
754
24
    MockCallsMatch,
755
25
    MockNotCalled,
756
26
    )
757
27
from mock import (
758
28
    call,
759
29
    Mock,
760
30
    sentinel,
761
31
    )
764
32
from provisioningserver.boot import tftppath
22
from provisioningserver.boot import tftppath
765
33
from provisioningserver.config import Config
23
from provisioningserver.config import Config
766
34
from provisioningserver.import_images import boot_resources
24
from provisioningserver.import_images import boot_resources
767
@@ -37,22 +27,11 @@
768
37
    _run_import,
27
    _run_import,
769
38
    import_boot_images,
28
    import_boot_images,
770
39
    list_boot_images,
29
    list_boot_images,
771
40
    PeriodicImageDownloadService,
772
41
    service_lock,
773
42
    )
774
43
from provisioningserver.rpc.exceptions import NoConnectionsAvailable
775
44
from provisioningserver.rpc.region import (
776
45
    GetBootSources,
777
46
    GetBootSourcesV2,
778
47
    )
30
    )
779
48
from provisioningserver.testing.config import BootSourcesFixture
31
from provisioningserver.testing.config import BootSourcesFixture
780
49
from provisioningserver.testing.testcase import PservTestCase
32
from provisioningserver.testing.testcase import PservTestCase
781
50
from provisioningserver.utils.twisted import pause
782
51
from testtools.deferredruntest import AsynchronousDeferredRunTest
33
from testtools.deferredruntest import AsynchronousDeferredRunTest
783
52
from twisted.application.internet import TimerService
784
53
from twisted.internet import defer
34
from twisted.internet import defer
785
54
from twisted.internet.task import Clock
786
55
from twisted.spread.pb import NoSuchMethod
787
56
35
788
57
36
789
58
class TestListBootImages(PservTestCase):
37
class TestListBootImages(PservTestCase):
790
@@ -145,232 +124,3 @@
791
145
        self.assertThat(
124
        self.assertThat(
792
146
            deferToThread, MockCalledOnceWith(
125
            deferToThread, MockCalledOnceWith(
793
147
                _run_import, sentinel.sources))
126
                _run_import, sentinel.sources))
794
148
795
149
796
150
class TestPeriodicImageDownloadService(PservTestCase):
797
151
798
152
    run_tests_with = AsynchronousDeferredRunTest.make_factory(timeout=5)
799
153
800
154
    def test_init(self):
801
155
        service = PeriodicImageDownloadService(
802
156
            sentinel.service, sentinel.clock, sentinel.uuid)
803
157
        self.assertIsInstance(service, TimerService)
804
158
        self.assertIs(service.clock, sentinel.clock)
805
159
        self.assertIs(service.uuid, sentinel.uuid)
806
160
        self.assertIs(service.client_service, sentinel.service)
807
161
808
162
    def patch_download(self, service, return_value):
809
163
        patched = self.patch(service, '_start_download')
810
164
        patched.return_value = defer.succeed(return_value)
811
165
        return patched
812
166
813
167
    def test_is_called_every_interval(self):
814
168
        clock = Clock()
815
169
        service = PeriodicImageDownloadService(
816
170
            sentinel.service, clock, sentinel.uuid)
817
171
        # Avoid actual downloads:
818
172
        self.patch_download(service, None)
819
173
        maas_meta_last_modified = self.patch(
820
174
            tftppath, 'maas_meta_last_modified')
821
175
        maas_meta_last_modified.return_value = None
822
176
        service.startService()
823
177
824
178
        # The first call is issued at startup.
825
179
        self.assertEqual(1, len(get_mock_calls(maas_meta_last_modified)))
826
180
827
181
        # Wind clock forward one second less than the desired interval.
828
182
        clock.advance(service.check_interval - 1)
829
183
        # No more periodic calls made.
830
184
        self.assertEqual(1, len(get_mock_calls(maas_meta_last_modified)))
831
185
832
186
        # Wind clock forward one second, past the interval.
833
187
        clock.advance(1)
834
188
835
189
        # Now there were two calls.
836
190
        self.assertEqual(2, len(get_mock_calls(maas_meta_last_modified)))
837
191
838
192
        # Forward another interval, should be three calls.
839
193
        clock.advance(service.check_interval)
840
194
        self.assertEqual(3, len(get_mock_calls(maas_meta_last_modified)))
841
195
842
196
    def test_no_download_if_no_meta_file(self):
843
197
        clock = Clock()
844
198
        service = PeriodicImageDownloadService(
845
199
            sentinel.service, clock, sentinel.uuid)
846
200
        _start_download = self.patch_download(service, None)
847
201
        self.patch(
848
202
            tftppath,
849
203
            'maas_meta_last_modified').return_value = None
850
204
        service.startService()
851
205
        self.assertThat(_start_download, MockNotCalled())
852
206
853
207
    def test_initiates_download_if_15_minutes_has_passed(self):
854
208
        clock = Clock()
855
209
        service = PeriodicImageDownloadService(
856
210
            sentinel.service, clock, sentinel.uuid)
857
211
        _start_download = self.patch_download(service, None)
858
212
        one_week_ago = clock.seconds() - timedelta(minutes=15).total_seconds()
859
213
        self.patch(
860
214
            tftppath,
861
215
            'maas_meta_last_modified').return_value = one_week_ago
862
216
        service.startService()
863
217
        self.assertThat(_start_download, MockCalledOnceWith())
864
218
865
219
    def test_no_download_if_15_minutes_has_not_passed(self):
866
220
        clock = Clock()
867
221
        service = PeriodicImageDownloadService(
868
222
            sentinel.service, clock, sentinel.uuid)
869
223
        _start_download = self.patch_download(service, None)
870
224
        one_week = timedelta(minutes=15).total_seconds()
871
225
        self.patch(
872
226
            tftppath,
873
227
            'maas_meta_last_modified').return_value = clock.seconds()
874
228
        clock.advance(one_week - 1)
875
229
        service.startService()
876
230
        self.assertThat(_start_download, MockNotCalled())
877
231
878
232
    def test_download_is_initiated_in_new_thread(self):
879
233
        clock = Clock()
880
234
        maas_meta_last_modified = self.patch(
881
235
            tftppath, 'maas_meta_last_modified')
882
236
        one_week = timedelta(minutes=15).total_seconds()
883
237
        maas_meta_last_modified.return_value = clock.seconds() - one_week
884
238
        rpc_client = Mock()
885
239
        client_call = Mock()
886
240
        client_call.side_effect = [
887
241
            defer.succeed(dict(sources=sentinel.sources)),
888
242
            ]
889
243
        rpc_client.getClient.return_value = client_call
890
244
891
245
        # We could patch out 'import_boot_images' instead here but I
892
246
        # don't do that for 2 reasons:
893
247
        # 1. It requires spinning the reactor again before being able to
894
248
        # test the result.
895
249
        # 2. It means there's no thread to clean up after the test.
896
250
        deferToThread = self.patch(boot_images, 'deferToThread')
897
251
        deferToThread.return_value = defer.succeed(None)
898
252
        service = PeriodicImageDownloadService(
899
253
            rpc_client, clock, sentinel.uuid)
900
254
        service.startService()
901
255
        self.assertThat(
902
256
            deferToThread, MockCalledOnceWith(
903
257
                _run_import, sentinel.sources))
904
258
905
259
    def test_no_download_if_no_rpc_connections(self):
906
260
        rpc_client = Mock()
907
261
        failure = NoConnectionsAvailable()
908
262
        rpc_client.getClient.return_value.side_effect = failure
909
263
910
264
        deferToThread = self.patch(boot_images, 'deferToThread')
911
265
        service = PeriodicImageDownloadService(
912
266
            rpc_client, Clock(), sentinel.uuid)
913
267
        service.startService()
914
268
        self.assertThat(deferToThread, MockNotCalled())
915
269
916
270
    @defer.inlineCallbacks
917
271
    def test_does_not_run_if_lock_taken(self):
918
272
        maas_meta_last_modified = self.patch(
919
273
            tftppath, 'maas_meta_last_modified')
920
274
        yield service_lock.acquire()
921
275
        self.addCleanup(service_lock.release)
922
276
        service = PeriodicImageDownloadService(
923
277
            sentinel.rpc, Clock(), sentinel.uuid)
924
278
        service.startService()
925
279
        self.assertThat(maas_meta_last_modified, MockNotCalled())
926
280
927
281
    def test_takes_lock_when_running(self):
928
282
        clock = Clock()
929
283
        service = PeriodicImageDownloadService(
930
284
            sentinel.rpc, clock, sentinel.uuid)
931
285
932
286
        # Patch the download func so it's just a Deferred that waits for
933
287
        # one second.
934
288
        _start_download = self.patch(service, '_start_download')
935
289
        _start_download.return_value = pause(1, clock)
936
290
937
291
        # Set conditions for a required download:
938
292
        one_week_ago = clock.seconds() - timedelta(minutes=15).total_seconds()
939
293
        self.patch(
940
294
            tftppath,
941
295
            'maas_meta_last_modified').return_value = one_week_ago
942
296
943
297
        # Lock is acquired for the first download after startup.
944
298
        service.startService()
945
299
        self.assertTrue(service_lock.locked)
946
300
947
301
        # Lock is released once the download is done.
948
302
        clock.advance(1)
949
303
        self.assertFalse(service_lock.locked)
950
304
951
305
    @defer.inlineCallbacks
952
306
    def test__get_boot_sources_calls_get_boot_sources_v2_before_v1(self):
953
307
        clock = Clock()
954
308
        client_call = Mock()
955
309
        client_call.side_effect = [
956
310
            defer.succeed(dict(sources=sentinel.sources)),
957
311
            ]
958
312
959
313
        service = PeriodicImageDownloadService(
960
314
            sentinel.rpc, clock, sentinel.uuid)
961
315
        sources = yield service._get_boot_sources(client_call)
962
316
        self.assertEqual(sources.get('sources'), sentinel.sources)
963
317
        self.assertThat(
964
318
            client_call,
965
319
            MockCalledOnceWith(GetBootSourcesV2, uuid=sentinel.uuid))
966
320
967
321
    @defer.inlineCallbacks
968
322
    def test__get_boot_sources_calls_get_boot_sources_v1_on_v2_missing(self):
969
323
        clock = Clock()
970
324
        client_call = Mock()
971
325
        client_call.side_effect = [
972
326
            defer.fail(NoSuchMethod()),
973
327
            defer.succeed(dict(sources=[])),
974
328
            ]
975
329
976
330
        service = PeriodicImageDownloadService(
977
331
            sentinel.rpc, clock, sentinel.uuid)
978
332
        yield service._get_boot_sources(client_call)
979
333
        self.assertThat(
980
334
            client_call,
981
335
            MockCallsMatch(
982
336
                call(GetBootSourcesV2, uuid=sentinel.uuid),
983
337
                call(GetBootSources, uuid=sentinel.uuid)))
984
338
985
339
    @defer.inlineCallbacks
986
340
    def test__get_boot_sources_v1_sets_os_to_wildcard(self):
987
341
        sources = [
988
342
            {
989
343
                'path': factory.make_url(),
990
344
                'selections': [
991
345
                    {
992
346
                        'release': "trusty",
993
347
                        'arches': ["amd64"],
994
348
                        'subarches': ["generic"],
995
349
                        'labels': ["release"],
996
350
                    },
997
351
                    {
998
352
                        'release': "precise",
999
353
                        'arches': ["amd64"],
1000
354
                        'subarches': ["generic"],
1001
355
                        'labels': ["release"],
1002
356
                    },
1003
357
                ],
1004
358
            },
1005
359
        ]
1006
360
1007
361
        clock = Clock()
1008
362
        client_call = Mock()
1009
363
        client_call.side_effect = [
1010
364
            defer.fail(NoSuchMethod()),
1011
365
            defer.succeed(dict(sources=sources)),
1012
366
            ]
1013
367
1014
368
        service = PeriodicImageDownloadService(
1015
369
            sentinel.rpc, clock, sentinel.uuid)
1016
370
        sources = yield service._get_boot_sources(client_call)
1017
371
        os_selections = [
1018
372
            selection.get('os')
1019
373
            for source in sources['sources']
1020
374
            for selection in source['selections']
1021
375
            ]
1022
376
        self.assertEqual(['*', '*'], os_selections)
1023
377
127
1024
=== modified file 'src/provisioningserver/tests/test_plugin.py'
1025
--- src/provisioningserver/tests/test_plugin.py	2014-08-26 23:55:04 +0000
1026
+++ src/provisioningserver/tests/test_plugin.py	2014-08-27 06:01:25 +0000
1027
@@ -27,9 +27,13 @@
1028
27
    ProvisioningServiceMaker,
27
    ProvisioningServiceMaker,
1029
28
    SingleUsernamePasswordChecker,
28
    SingleUsernamePasswordChecker,
1030
29
    )
29
    )
1034
30
from provisioningserver.rpc.boot_images import PeriodicImageDownloadService
30
from provisioningserver.pserv_services.image_download_service import (
1035
31
from provisioningserver.rpc.power import NodePowerMonitorService
31
    PeriodicImageDownloadService,
1036
32
from provisioningserver.tftp import (
32
    )
1037
33
from provisioningserver.pserv_services.node_power_monitor_service import (
1038
34
    NodePowerMonitorService,
1039
35
    )
1040
36
from provisioningserver.pserv_services.tftp import (
1041
33
    TFTPBackend,
37
    TFTPBackend,
1042
34
    TFTPService,
38
    TFTPService,
1043
35
    )
39
    )
1044
36
40
1045
=== modified file 'src/provisioningserver/tests/test_tftp.py'
1046
--- src/provisioningserver/tests/test_tftp.py	2014-08-13 21:49:35 +0000
1047
+++ src/provisioningserver/tests/test_tftp.py	2014-08-27 06:01:25 +0000
1048
@@ -37,17 +37,17 @@
1049
37
    IPV4_LINK_LOCAL,
37
    IPV4_LINK_LOCAL,
1050
38
    IPV6_LINK_LOCAL,
38
    IPV6_LINK_LOCAL,
1051
39
    )
39
    )
1052
40
from provisioningserver import tftp as tftp_module
1053
41
from provisioningserver.boot import BytesReader
40
from provisioningserver.boot import BytesReader
1054
42
from provisioningserver.boot.pxe import PXEBootMethod
41
from provisioningserver.boot.pxe import PXEBootMethod
1055
43
from provisioningserver.boot.tests.test_pxe import compose_config_path
42
from provisioningserver.boot.tests.test_pxe import compose_config_path
1058
44
from provisioningserver.tests.test_kernel_opts import make_kernel_parameters
43
from provisioningserver.pserv_services import tftp as tftp_module
1059
45
from provisioningserver.tftp import (
44
from provisioningserver.pserv_services.tftp import (
1060
46
    Port,
45
    Port,
1061
47
    TFTPBackend,
46
    TFTPBackend,
1062
48
    TFTPService,
47
    TFTPService,
1063
49
    UDPServer,
48
    UDPServer,
1064
50
    )
49
    )
1065
50
from provisioningserver.tests.test_kernel_opts import make_kernel_parameters
1066
51
from testtools.deferredruntest import AsynchronousDeferredRunTest
51
from testtools.deferredruntest import AsynchronousDeferredRunTest
1067
52
from testtools.matchers import (
52
from testtools.matchers import (
1068
53
    AfterPreprocessing,
53
    AfterPreprocessing,
Status:	Merged
Approved by:	Julian Edwards on 2014-08-27
Approved revision:	no longer in the source branch.
Merged at revision:	2827
Proposed branch:	lp:~julian-edwards/maas/pserv-services-dir
Merge into:	lp:~maas-committers/maas/trunk
Diff against target:	1068 lines (+499/-414) 10 files modified src/provisioningserver/boot/tests/test_powernv.py (+1/-1) src/provisioningserver/plugin.py (+7/-3) src/provisioningserver/pserv_services/image_download_service.py (+120/-0) src/provisioningserver/pserv_services/node_power_monitor_service.py (+75/-0) src/provisioningserver/pserv_services/tests/test_image_download_service.py (+279/-0) src/provisioningserver/rpc/boot_images.py (+2/-103) src/provisioningserver/rpc/power.py (+3/-49) src/provisioningserver/rpc/tests/test_boot_images.py (+2/-252) src/provisioningserver/tests/test_plugin.py (+7/-3) src/provisioningserver/tests/test_tftp.py (+3/-3)
To merge this branch:	bzr merge lp:~julian-edwards/maas/pserv-services-dir
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Jeroen T. Vermeulen (community)		2014-08-27	Approve on 2014-08-27
Review via email: mp+232344@code.launchpad.net