1
diff --git a/debian/maas-region-api.dirs b/debian/maas-region-api.dirs
2
index d5ba327..1e65cfa 100644
3
--- a/debian/maas-region-api.dirs
4
+++ b/debian/maas-region-api.dirs
5
@@ -1,2 +1,3 @@
6
1
etc/bind/maas
1
etc/bind/maas
7
2
var/lib/bind/maas
8
2
var/lib/maas/prometheus
3
var/lib/maas/prometheus
9
diff --git a/debian/maas-region-api.postinst b/debian/maas-region-api.postinst
10
index a1fb1a1..778504d 100644
11
--- a/debian/maas-region-api.postinst
12
+++ b/debian/maas-region-api.postinst
13
@@ -30,6 +30,11 @@ configure_libdir() {
14
30
    if [ -f /var/lib/maas/maas_id ]; then
30
    if [ -f /var/lib/maas/maas_id ]; then
15
31
       chown maas:maas /var/lib/maas/maas_id
31
       chown maas:maas /var/lib/maas/maas_id
16
32
    fi
32
    fi
17
33
18
34
    if [ -d /var/lib/maas/bind ]; then
19
35
        chown maas:bind /var/lib/bind/maas
20
36
        chmod 0775 /var/lib/bind/maas
21
37
    fi
22
33
}
38
}
23
34
39
24
35
edit_named_options() {
40
edit_named_options() {
25
diff --git a/src/maasserver/dns/config.py b/src/maasserver/dns/config.py
26
index 102e33d..c484570 100644
27
--- a/src/maasserver/dns/config.py
28
+++ b/src/maasserver/dns/config.py
29
@@ -17,7 +17,9 @@ from maasserver.dns.zonegenerator import (
30
17
)
17
)
31
18
from maasserver.enum import IPADDRESS_TYPE, RDNS_MODE
18
from maasserver.enum import IPADDRESS_TYPE, RDNS_MODE
32
19
from maasserver.models.config import Config
19
from maasserver.models.config import Config
33
20
from maasserver.models.dnsdata import DNSData
34
20
from maasserver.models.dnspublication import DNSPublication
21
from maasserver.models.dnspublication import DNSPublication
35
22
from maasserver.models.dnsresource import DNSResource
36
21
from maasserver.models.domain import Domain
23
from maasserver.models.domain import Domain
37
22
from maasserver.models.node import RackController
24
from maasserver.models.node import RackController
38
23
from maasserver.models.subnet import Subnet
25
from maasserver.models.subnet import Subnet
39
@@ -28,7 +30,9 @@ from provisioningserver.dns.actions import (
40
28
    bind_write_options,
30
    bind_write_options,
41
29
    bind_write_zones,
31
    bind_write_zones,
42
30
)
32
)
43
33
from provisioningserver.dns.config import DynamicDNSUpdate
44
31
from provisioningserver.logger import get_maas_logger
34
from provisioningserver.logger import get_maas_logger
45
35
from provisioningserver.utils.shell import ExternalProcessError
46
32
36
47
33
maaslog = get_maas_logger("dns")
37
maaslog = get_maas_logger("dns")
48
34
38
49
@@ -61,7 +65,12 @@ def forward_domains_to_forwarded_zones(forward_domains):
50
61
    ]
65
    ]
51
62
66
52
63
67
54
64
def dns_update_all_zones(reload_retry=False, reload_timeout=2):
68
def dns_update_all_zones(
55
69
    reload_retry=False,
56
70
    reload_timeout=2,
57
71
    dynamic_updates=None,
58
72
    requires_reload=False,
59
73
):
60
65
    """Update all zone files for all domains.
74
    """Update all zone files for all domains.
61
66
75
62
67
    Serving these zone files means updating BIND's configuration to include
76
    Serving these zone files means updating BIND's configuration to include
63
@@ -70,10 +79,23 @@ def dns_update_all_zones(reload_retry=False, reload_timeout=2):
64
70
    :param reload_retry: Should the DNS server reload be retried in case
79
    :param reload_retry: Should the DNS server reload be retried in case
65
71
        of failure? Defaults to `False`.
80
        of failure? Defaults to `False`.
66
72
    :type reload_retry: bool
81
    :type reload_retry: bool
67
82
68
83
    :param reload_timeout: How many seconds to wait for BIND's reload to succeed
69
84
    :type reload_timeout: int
70
85
71
86
    :param dynamic_updates: A list of updates to send via nsupdate to BIND
72
87
    :type dynamic_updates: list[DynamicDNSUpdate]
73
88
74
89
    :param requires_reload: If true, dynamic updates are ignored and a full reload will occur
75
90
    :type requires_reload: bool
76
73
    """
91
    """
77
74
    if not is_dns_enabled():
92
    if not is_dns_enabled():
78
75
        return
93
        return
79
76
94
80
95
    if not dynamic_updates:
81
96
        dynamic_updates = []
82
97
83
98
    reloaded = True
84
77
    domains = Domain.objects.filter(authoritative=True)
99
    domains = Domain.objects.filter(authoritative=True)
85
78
    forwarded_zones = forward_domains_to_forwarded_zones(
100
    forwarded_zones = forward_domains_to_forwarded_zones(
86
79
        Domain.objects.get_forward_domains()
101
        Domain.objects.get_forward_domains()
87
@@ -87,8 +109,13 @@ def dns_update_all_zones(reload_retry=False, reload_timeout=2):
88
87
        default_ttl,
109
        default_ttl,
89
88
        serial,
110
        serial,
90
89
        internal_domains=[get_internal_domain()],
111
        internal_domains=[get_internal_domain()],
91
112
        dynamic_updates=dynamic_updates,
92
113
        force_config_write=requires_reload,
93
90
    ).as_list()
114
    ).as_list()
95
91
    bind_write_zones(zones)
115
    try:
96
116
        bind_write_zones(zones)
97
117
    except ExternalProcessError:  # dynamic update failed
98
118
        reloaded = False
99
92
119
100
93
    # We should not be calling bind_write_options() here; call-sites should be
120
    # We should not be calling bind_write_options() here; call-sites should be
101
94
    # making a separate call. It's a historical legacy, where many sites now
121
    # making a separate call. It's a historical legacy, where many sites now
102
@@ -110,14 +137,21 @@ def dns_update_all_zones(reload_retry=False, reload_timeout=2):
103
110
        forwarded_zones=forwarded_zones,
137
        forwarded_zones=forwarded_zones,
104
111
    )
138
    )
105
112
139
114
113
    # Reloading with retries may be a legacy from Celery days, or it may be
140
    if not requires_reload:
115
114
    # necessary to recover from races during start-up. We're not sure if it is
141
        for zone in zones:
116
115
    # actually needed but it seems safer to maintain this behaviour until we
142
            if zone.requires_reload:
117
116
    # have a better understanding.
143
                requires_reload = True
118
117
    if reload_retry:
144
                break
119
118
        reloaded = bind_reload_with_retries(timeout=reload_timeout)
145
120
119
    else:
146
    if requires_reload:
121
120
        reloaded = bind_reload(timeout=reload_timeout)
147
        # Reloading with retries may be a legacy from Celery days, or it may be
122
148
        # necessary to recover from races during start-up. We're not sure if it is
123
149
        # actually needed but it seems safer to maintain this behaviour until we
124
150
        # have a better understanding.
125
151
        if reload_retry:
126
152
            reloaded = bind_reload_with_retries(timeout=reload_timeout)
127
153
        else:
128
154
            reloaded = bind_reload(timeout=reload_timeout)
129
121
155
130
122
    # Return the current serial and list of domain names.
156
    # Return the current serial and list of domain names.
131
123
    return serial, reloaded, [domain.name for domain in domains]
157
    return serial, reloaded, [domain.name for domain in domains]
132
@@ -251,3 +285,121 @@ def get_internal_domain():
133
251
        ttl=15,
285
        ttl=15,
134
252
        resources=resources,
286
        resources=resources,
135
253
    )
287
    )
136
288
137
289
138
290
def process_dns_update_notify(message):
139
291
    updates = []
140
292
    update_list = message.split(" ")
141
293
    op = update_list[0]
142
294
    zone = None
143
295
    name = None
144
296
    rectype = None
145
297
    ttl = None
146
298
    answer = None
147
299
    if op == "RELOAD":
148
300
        return (updates, True)
149
301
    elif op == "INSERT-DATA" or op == "UPDATE-DATA":
150
302
        dns_data = DNSData.objects.get(id=int(update_list[1]))
151
303
        zone = dns_data.dnsresource.domain.name
152
304
        name = dns_data.dnsresource.name
153
305
        ttl = dns_data.ttl
154
306
        rectype = dns_data.rrtype
155
307
        answer = dns_data.rrdata
156
308
    else:
157
309
        zone = update_list[1]
158
310
        name = f"{update_list[2]}.{zone}"
159
311
        rectype = update_list[3]
160
312
        if op == "INSERT" or op == "UPDATE":
161
313
            ttl = int(update_list[-2]) if update_list[-2] else None
162
314
            answer = update_list[-1]
163
315
164
316
    match op:
165
317
        case "UPDATE":
166
318
            updates.append(
167
319
                DynamicDNSUpdate.create_from_trigger(
168
320
                    operation="DELETE",
169
321
                    zone=zone,
170
322
                    name=name,
171
323
                    rectype=rectype,
172
324
                    answer=answer,
173
325
                )
174
326
            )
175
327
            updates.append(
176
328
                DynamicDNSUpdate.create_from_trigger(
177
329
                    operation="INSERT",
178
330
                    zone=zone,
179
331
                    name=name,
180
332
                    rectype=rectype,
181
333
                    ttl=ttl,
182
334
                    answer=answer,
183
335
                )
184
336
            )
185
337
        case "INSERT":
186
338
            updates.append(
187
339
                DynamicDNSUpdate.create_from_trigger(
188
340
                    operation=op,
189
341
                    zone=zone,
190
342
                    name=name,
191
343
                    rectype=rectype,
192
344
                    ttl=ttl,
193
345
                    answer=answer,
194
346
                )
195
347
            )
196
348
        case _:
197
349
            # special case where we know an IP has been deleted but, we can't fetch the value
198
350
            # and the rrecord may still have other answers
199
351
            if op == "DELETE-IP":
200
352
                updates.append(
201
353
                    DynamicDNSUpdate.create_from_trigger(
202
354
                        operation="DELETE",
203
355
                        zone=zone,
204
356
                        name=name,
205
357
                        rectype=rectype,
206
358
                    )
207
359
                )
208
360
                if rectype == "A":
209
361
                    updates.append(
210
362
                        DynamicDNSUpdate.create_from_trigger(
211
363
                            operation="DELETE",
212
364
                            zone=zone,
213
365
                            name=name,
214
366
                            rectype="AAAA",
215
367
                        )
216
368
                    )
217
369
                resource = DNSResource.objects.get(
218
370
                    name=update_list[2], domain__name=zone
219
371
                )
220
372
                updates += [
221
373
                    DynamicDNSUpdate.create_from_trigger(
222
374
                        operation="INSERT",
223
375
                        zone=zone,
224
376
                        name=name,
225
377
                        rectype=rectype,
226
378
                        ttl=int(resource.address_ttl)
227
379
                        if resource.address_ttl
228
380
                        else None,
229
381
                        answer=ip.ip,
230
382
                    )
231
383
                    for ip in resource.ip_addresses.all()
232
384
                ]
233
385
234
386
            elif len(update_list) > 4:  # has an answer
235
387
                updates.append(
236
388
                    DynamicDNSUpdate.create_from_trigger(
237
389
                        operation=op,
238
390
                        zone=zone,
239
391
                        name=name,
240
392
                        rectype=rectype,
241
393
                        answer=update_list[-1],
242
394
                    )
243
395
                )
244
396
            else:
245
397
                updates.append(
246
398
                    DynamicDNSUpdate.create_from_trigger(
247
399
                        operation=op,
248
400
                        zone=zone,
249
401
                        name=name,
250
402
                        rectype=rectype,
251
403
                    )
252
404
                )
253
405
    return (updates, False)
254
diff --git a/src/maasserver/dns/tests/test_config.py b/src/maasserver/dns/tests/test_config.py
255
index 1b2f15a..913c96e 100644
256
--- a/src/maasserver/dns/tests/test_config.py
257
+++ b/src/maasserver/dns/tests/test_config.py
258
@@ -29,6 +29,7 @@ from maasserver.dns.config import (
259
29
    get_trusted_acls,
29
    get_trusted_acls,
260
30
    get_trusted_networks,
30
    get_trusted_networks,
261
31
    get_upstream_dns,
31
    get_upstream_dns,
262
32
    process_dns_update_notify,
263
32
)
33
)
264
33
from maasserver.dns.zonegenerator import InternalDomainResourseRecord
34
from maasserver.dns.zonegenerator import InternalDomainResourseRecord
265
34
from maasserver.enum import IPADDRESS_TYPE, NODE_STATUS
35
from maasserver.enum import IPADDRESS_TYPE, NODE_STATUS
266
@@ -40,10 +41,15 @@ from maasserver.testing.factory import factory
267
40
from maasserver.testing.testcase import MAASServerTestCase
41
from maasserver.testing.testcase import MAASServerTestCase
268
41
from maastesting.matchers import MockCalledOnceWith
42
from maastesting.matchers import MockCalledOnceWith
269
42
from provisioningserver.dns.commands import get_named_conf, setup_dns
43
from provisioningserver.dns.commands import get_named_conf, setup_dns
271
43
from provisioningserver.dns.config import compose_config_path, DNSConfig
44
from provisioningserver.dns.config import (
272
45
    compose_config_path,
273
46
    DNSConfig,
274
47
    DynamicDNSUpdate,
275
48
)
276
44
from provisioningserver.dns.testing import (
49
from provisioningserver.dns.testing import (
277
45
    patch_dns_config_path,
50
    patch_dns_config_path,
278
46
    patch_dns_rndc_port,
51
    patch_dns_rndc_port,
279
52
    patch_zone_file_config_path,
280
47
)
53
)
281
48
from provisioningserver.testing.bindfixture import allocate_ports, BINDServer
54
from provisioningserver.testing.bindfixture import allocate_ports, BINDServer
282
49
from provisioningserver.testing.tests.test_bindfixture import dig_call
55
from provisioningserver.testing.tests.test_bindfixture import dig_call
283
@@ -127,6 +133,7 @@ class TestDNSServer(MAASServerTestCase):
284
127
        patch_dns_config_path(self, self.bind.config.homedir)
133
        patch_dns_config_path(self, self.bind.config.homedir)
285
128
        # Use a random port for rndc.
134
        # Use a random port for rndc.
286
129
        patch_dns_rndc_port(self, allocate_ports("localhost")[0])
135
        patch_dns_rndc_port(self, allocate_ports("localhost")[0])
287
136
        patch_zone_file_config_path(self, config_dir=self.bind.config.homedir)
288
130
        # This simulates what should happen when the package is
137
        # This simulates what should happen when the package is
289
131
        # installed:
138
        # installed:
290
132
        # Create MAAS-specific DNS configuration files.
139
        # Create MAAS-specific DNS configuration files.
291
@@ -431,6 +438,28 @@ class TestDNSConfigModifications(TestDNSServer):
292
431
            ),
438
            ),
293
432
        )
439
        )
294
433
440
295
441
    def test_dns_update_all_zones_does_not_reload_if_it_does_not_need_to(self):
296
442
        self.patch(settings, "DNS_CONNECT", True)
297
443
        domain = factory.make_Domain()
298
444
        # These domains should not show up. Just to test we create them.
299
445
        for _ in range(3):
300
446
            factory.make_Domain(authoritative=False)
301
447
        node, static = self.create_node_with_static_ip(domain=domain)
302
448
        fake_serial = random.randint(1, 1000)
303
449
        self.patch(
304
450
            dns_config_module, "current_zone_serial"
305
451
        ).return_value = fake_serial
306
452
        reload_call = self.patch(dns_config_module, "bind_reload")
307
453
        serial1, reloaded, _ = dns_update_all_zones(
308
454
            reload_timeout=RELOAD_TIMEOUT
309
455
        )
310
456
        self.assertTrue(reloaded)
311
457
        factory.make_DNSResource(domain=domain)
312
458
        _, _, _ = dns_update_all_zones(  # should be a dynamic update
313
459
            reload_timeout=RELOAD_TIMEOUT
314
460
        )
315
461
        reload_call.assert_called_once()
316
462
317
434
463
318
435
class TestDNSDynamicIPAddresses(TestDNSServer):
464
class TestDNSDynamicIPAddresses(TestDNSServer):
319
436
    """Allocated nodes with IP addresses in the dynamic range get a DNS
465
    """Allocated nodes with IP addresses in the dynamic range get a DNS
320
@@ -754,3 +783,122 @@ class TestGetResourceNameForSubnet(MAASServerTestCase):
321
754
    def test_returns_valid(self):
783
    def test_returns_valid(self):
322
755
        subnet = factory.make_Subnet(cidr=self.cidr)
784
        subnet = factory.make_Subnet(cidr=self.cidr)
323
756
        self.assertEqual(self.result, get_resource_name_for_subnet(subnet))
785
        self.assertEqual(self.result, get_resource_name_for_subnet(subnet))
324
786
325
787
326
788
class TestProcessDNSUpdateNotify(MAASServerTestCase):
327
789
    def test_insert(self):
328
790
        domain = factory.make_Domain()
329
791
        resource = factory.make_DNSResource(domain=domain)
330
792
        ip = resource.ip_addresses.first().ip
331
793
        message = f"INSERT {domain.name} {resource.name} A {resource.address_ttl if resource.address_ttl else 60} {ip}"
332
794
        result, _ = process_dns_update_notify(message)
333
795
        self.assertCountEqual(
334
796
            [
335
797
                DynamicDNSUpdate(
336
798
                    operation="INSERT",
337
799
                    zone=domain.name,
338
800
                    name=f"{resource.name}.{domain.name}",
339
801
                    ttl=resource.address_ttl if resource.address_ttl else 60,
340
802
                    answer=ip,
341
803
                    rectype="A" if IPAddress(ip).version == 4 else "AAAA",
342
804
                )
343
805
            ],
344
806
            result,
345
807
        )
346
808
347
809
    def test_delete_without_ip(self):
348
810
        domain = factory.make_Domain()
349
811
        resource = factory.make_DNSResource(domain=domain)
350
812
        message = f"DELETE {domain.name} {resource.name} A"
351
813
        result, _ = process_dns_update_notify(message)
352
814
        self.assertCountEqual(
353
815
            [
354
816
                DynamicDNSUpdate(
355
817
                    operation="DELETE",
356
818
                    zone=domain.name,
357
819
                    name=f"{resource.name}.{domain.name}",
358
820
                    rectype="A",
359
821
                )
360
822
            ],
361
823
            result,
362
824
        )
363
825
364
826
    def test_delete_with_ip(self):
365
827
        domain = factory.make_Domain()
366
828
        resource = factory.make_DNSResource(domain=domain)
367
829
        ip = resource.ip_addresses.first().ip
368
830
        message = f"DELETE {domain.name} {resource.name} A {ip}"
369
831
        result, _ = process_dns_update_notify(message)
370
832
        self.assertCountEqual(
371
833
            [
372
834
                DynamicDNSUpdate(
373
835
                    operation="DELETE",
374
836
                    zone=domain.name,
375
837
                    name=f"{resource.name}.{domain.name}",
376
838
                    answer=ip,
377
839
                    rectype="A" if IPAddress(ip).version == 4 else "AAAA",
378
840
                )
379
841
            ],
380
842
            result,
381
843
        )
382
844
383
845
    def test_update(self):
384
846
        domain = factory.make_Domain()
385
847
        resource = factory.make_DNSResource(domain=domain)
386
848
        ip = resource.ip_addresses.first().ip
387
849
        message = f"UPDATE {domain.name} {resource.name} A {resource.address_ttl if resource.address_ttl else 60} {ip}"
388
850
        result, _ = process_dns_update_notify(message)
389
851
        self.assertCountEqual(
390
852
            [
391
853
                DynamicDNSUpdate(
392
854
                    operation="DELETE",
393
855
                    zone=domain.name,
394
856
                    name=f"{resource.name}.{domain.name}",
395
857
                    answer=ip,
396
858
                    rectype="A" if IPAddress(ip).version == 4 else "AAAA",
397
859
                ),
398
860
                DynamicDNSUpdate(
399
861
                    operation="INSERT",
400
862
                    zone=domain.name,
401
863
                    name=f"{resource.name}.{domain.name}",
402
864
                    ttl=resource.address_ttl if resource.address_ttl else 60,
403
865
                    answer=ip,
404
866
                    rectype="A" if IPAddress(ip).version == 4 else "AAAA",
405
867
                ),
406
868
            ],
407
869
            result,
408
870
        )
409
871
410
872
    def test_delete_ip(self):
411
873
        domain = factory.make_Domain()
412
874
        resource = factory.make_DNSResource(domain=domain)
413
875
        ip = resource.ip_addresses.first().ip
414
876
        ip2 = factory.make_StaticIPAddress()
415
877
        resource.ip_addresses.add(ip2)
416
878
        message = f"DELETE-IP {domain.name} {resource.name} A {resource.address_ttl if resource.address_ttl else 60} {ip}"
417
879
        resource.ip_addresses.first().delete()
418
880
        result, _ = process_dns_update_notify(message)
419
881
        self.assertCountEqual(
420
882
            [
421
883
                DynamicDNSUpdate(
422
884
                    operation="DELETE",
423
885
                    zone=domain.name,
424
886
                    name=f"{resource.name}.{domain.name}",
425
887
                    rectype="A",
426
888
                ),
427
889
                DynamicDNSUpdate(
428
890
                    operation="DELETE",
429
891
                    zone=domain.name,
430
892
                    name=f"{resource.name}.{domain.name}",
431
893
                    rectype="AAAA",
432
894
                ),
433
895
                DynamicDNSUpdate(
434
896
                    operation="INSERT",
435
897
                    zone=domain.name,
436
898
                    name=f"{resource.name}.{domain.name}",
437
899
                    rectype="A" if IPAddress(ip2.ip).version == 4 else "AAAA",
438
900
                    answer=ip2.ip,
439
901
                ),
440
902
            ],
441
903
            result,
442
904
        )
443
diff --git a/src/maasserver/dns/zonegenerator.py b/src/maasserver/dns/zonegenerator.py
444
index 0e4c872..ef31cfa 100644
445
--- a/src/maasserver/dns/zonegenerator.py
446
+++ b/src/maasserver/dns/zonegenerator.py
447
@@ -21,6 +21,7 @@ from maasserver.models.domain import Domain
448
21
from maasserver.models.staticipaddress import StaticIPAddress
21
from maasserver.models.staticipaddress import StaticIPAddress
449
22
from maasserver.models.subnet import Subnet
22
from maasserver.models.subnet import Subnet
450
23
from maasserver.server_address import get_maas_facing_server_addresses
23
from maasserver.server_address import get_maas_facing_server_addresses
451
24
from provisioningserver.dns.config import DynamicDNSUpdate
452
24
from provisioningserver.dns.zoneconfig import (
25
from provisioningserver.dns.zoneconfig import (
453
25
    DNSForwardZoneConfig,
26
    DNSForwardZoneConfig,
454
26
    DNSReverseZoneConfig,
27
    DNSReverseZoneConfig,
455
@@ -200,6 +201,8 @@ class ZoneGenerator:
456
200
        default_ttl=None,
201
        default_ttl=None,
457
201
        serial=None,
202
        serial=None,
458
202
        internal_domains=None,
203
        internal_domains=None,
459
204
        dynamic_updates=None,
460
205
        force_config_write=False,
461
203
    ):
206
    ):
462
204
        """
207
        """
463
205
        :param serial: A serial number to reuse when creating zones in bulk.
208
        :param serial: A serial number to reuse when creating zones in bulk.
464
@@ -215,6 +218,10 @@ class ZoneGenerator:
465
215
        self.internal_domains = internal_domains
218
        self.internal_domains = internal_domains
466
216
        if self.internal_domains is None:
219
        if self.internal_domains is None:
467
217
            self.internal_domains = []
220
            self.internal_domains = []
468
221
        self._dynamic_updates = dynamic_updates
469
222
        if self._dynamic_updates is None:
470
223
            self._dynamic_updates = []
471
224
        self.force_config_write = force_config_write  # some data changed that nsupdate cannot update if true
472
218
225
473
219
    @staticmethod
226
    @staticmethod
474
220
    def _get_mappings():
227
    def _get_mappings():
475
@@ -235,6 +242,8 @@ class ZoneGenerator:
476
235
        rrset_mappings,
242
        rrset_mappings,
477
236
        default_ttl,
243
        default_ttl,
478
237
        internal_domains,
244
        internal_domains,
479
245
        dynamic_updates,
480
246
        force_config_write,
481
238
    ):
247
    ):
482
239
        """Generator of forward zones, collated by domain name."""
248
        """Generator of forward zones, collated by domain name."""
483
240
        dns_ip_list = get_dns_server_addresses(filter_allowed_dns=False)
249
        dns_ip_list = get_dns_server_addresses(filter_allowed_dns=False)
484
@@ -290,6 +299,12 @@ class ZoneGenerator:
485
290
                            (ttl, "AAAA", dns_ip.format())
299
                            (ttl, "AAAA", dns_ip.format())
486
291
                        )
300
                        )
487
292
301
488
302
            domain_updates = [
489
303
                update
490
304
                for update in dynamic_updates
491
305
                if update.zone == domain.name
492
306
            ]
493
307
494
293
            yield DNSForwardZoneConfig(
308
            yield DNSForwardZoneConfig(
495
294
                domain.name,
309
                domain.name,
496
295
                serial=serial,
310
                serial=serial,
497
@@ -301,6 +316,8 @@ class ZoneGenerator:
498
301
                ns_host_name=ns_host_name,
316
                ns_host_name=ns_host_name,
499
302
                other_mapping=other_mapping,
317
                other_mapping=other_mapping,
500
303
                dynamic_ranges=dynamic_ranges,
318
                dynamic_ranges=dynamic_ranges,
501
319
                dynamic_updates=domain_updates,
502
320
                force_config_write=force_config_write,
503
304
            )
321
            )
504
305
322
505
306
        # Create the forward zone config for the internal domains.
323
        # Create the forward zone config for the internal domains.
506
@@ -313,6 +330,13 @@ class ZoneGenerator:
507
313
                    resource_mapping.rrset.add(
330
                    resource_mapping.rrset.add(
508
314
                        (internal_domain.ttl, record.rrtype, record.rrdata)
331
                        (internal_domain.ttl, record.rrtype, record.rrdata)
509
315
                    )
332
                    )
510
333
511
334
            domain_updates = [
512
335
                update
513
336
                for update in dynamic_updates
514
337
                if update.zone == internal_domain.name
515
338
            ]
516
339
517
316
            yield DNSForwardZoneConfig(
340
            yield DNSForwardZoneConfig(
518
317
                internal_domain.name,
341
                internal_domain.name,
519
318
                serial=serial,
342
                serial=serial,
520
@@ -324,11 +348,19 @@ class ZoneGenerator:
521
324
                ns_host_name=ns_host_name,
348
                ns_host_name=ns_host_name,
522
325
                other_mapping=other_mapping,
349
                other_mapping=other_mapping,
523
326
                dynamic_ranges=[],
350
                dynamic_ranges=[],
524
351
                dynamic_updates=domain_updates,
525
352
                force_config_write=force_config_write,
526
327
            )
353
            )
527
328
354
528
329
    @staticmethod
355
    @staticmethod
529
330
    def _gen_reverse_zones(
356
    def _gen_reverse_zones(
531
331
        subnets, serial, ns_host_name, mappings, default_ttl
357
        subnets,
532
358
        serial,
533
359
        ns_host_name,
534
360
        mappings,
535
361
        default_ttl,
536
362
        dynamic_updates,
537
363
        force_config_write,
538
332
    ):
364
    ):
539
333
        """Generator of reverse zones, sorted by network."""
365
        """Generator of reverse zones, sorted by network."""
540
334
366
541
@@ -418,6 +450,15 @@ class ZoneGenerator:
542
418
                del rfc2317_glue[network]
450
                del rfc2317_glue[network]
543
419
            else:
451
            else:
544
420
                glue = set()
452
                glue = set()
545
453
546
454
            domain_updates = [
547
455
                DynamicDNSUpdate.as_reverse_record_update(update, subnet)
548
456
                for update in dynamic_updates
549
457
                if update.answer
550
458
                and update.answer_is_ip
551
459
                and (IPAddress(update.answer) in IPNetwork(subnet.cidr))
552
460
            ]
553
461
554
421
            yield DNSReverseZoneConfig(
462
            yield DNSReverseZoneConfig(
555
422
                ns_host_name,
463
                ns_host_name,
556
423
                serial=serial,
464
                serial=serial,
557
@@ -430,6 +471,8 @@ class ZoneGenerator:
558
430
                exclude={
471
                exclude={
559
431
                    IPNetwork(s.cidr) for s in subnets if s is not subnet
472
                    IPNetwork(s.cidr) for s in subnets if s is not subnet
560
432
                },
473
                },
561
474
                dynamic_updates=domain_updates,
562
475
                force_config_write=force_config_write,
563
433
            )
476
            )
564
434
        # Now provide any remaining rfc2317 glue networks.
477
        # Now provide any remaining rfc2317 glue networks.
565
435
        for network, ranges in rfc2317_glue.items():
478
        for network, ranges in rfc2317_glue.items():
566
@@ -445,6 +488,8 @@ class ZoneGenerator:
567
445
                    for s in subnets
488
                    for s in subnets
568
446
                    if network in IPNetwork(s.cidr)
489
                    if network in IPNetwork(s.cidr)
569
447
                },
490
                },
570
491
                dynamic_updates=domain_updates,
571
492
                force_config_write=force_config_write,
572
448
            )
493
            )
573
449
494
574
450
    def __iter__(self):
495
    def __iter__(self):
575
@@ -470,9 +515,17 @@ class ZoneGenerator:
576
470
                rrset_mappings,
515
                rrset_mappings,
577
471
                default_ttl,
516
                default_ttl,
578
472
                self.internal_domains,
517
                self.internal_domains,
579
518
                self._dynamic_updates,
580
519
                self.force_config_write,
581
473
            ),
520
            ),
582
474
            self._gen_reverse_zones(
521
            self._gen_reverse_zones(
584
475
                self.subnets, serial, ns_host_name, mappings, default_ttl
522
                self.subnets,
585
523
                serial,
586
524
                ns_host_name,
587
525
                mappings,
588
526
                default_ttl,
589
527
                self._dynamic_updates,
590
528
                self.force_config_write,
591
476
            ),
529
            ),
592
477
        )
530
        )
593
478
531
594
diff --git a/src/maasserver/region_controller.py b/src/maasserver/region_controller.py
595
index e795afb..69eae10 100644
596
--- a/src/maasserver/region_controller.py
597
+++ b/src/maasserver/region_controller.py
598
@@ -41,7 +41,10 @@ from twisted.internet.task import LoopingCall
599
41
from twisted.names.client import Resolver
41
from twisted.names.client import Resolver
600
42
42
601
43
from maasserver import eventloop, locks
43
from maasserver import eventloop, locks
603
44
from maasserver.dns.config import dns_update_all_zones
44
from maasserver.dns.config import (
604
45
    dns_update_all_zones,
605
46
    process_dns_update_notify,
606
47
)
607
45
from maasserver.macaroon_auth import get_auth_info
48
from maasserver.macaroon_auth import get_auth_info
608
46
from maasserver.models.dnspublication import DNSPublication
49
from maasserver.models.dnspublication import DNSPublication
609
47
from maasserver.models.rbacsync import RBAC_ACTION, RBACLastSync, RBACSync
50
from maasserver.models.rbacsync import RBAC_ACTION, RBACLastSync, RBACSync
610
@@ -94,6 +97,8 @@ class RegionControllerService(Service):
611
94
        self.needsDNSUpdate = False
97
        self.needsDNSUpdate = False
612
95
        self.needsProxyUpdate = False
98
        self.needsProxyUpdate = False
613
96
        self.needsRBACUpdate = False
99
        self.needsRBACUpdate = False
614
100
        self._dns_updates = []
615
101
        self._dns_requires_full_reload = False
616
97
        self.postgresListener = postgresListener
102
        self.postgresListener = postgresListener
617
98
        self.dnsResolver = Resolver(
103
        self.dnsResolver = Resolver(
618
99
            resolv=None,
104
            resolv=None,
619
@@ -110,6 +115,9 @@ class RegionControllerService(Service):
620
110
        """Start listening for messages."""
115
        """Start listening for messages."""
621
111
        super().startService()
116
        super().startService()
622
112
        self.postgresListener.register("sys_dns", self.markDNSForUpdate)
117
        self.postgresListener.register("sys_dns", self.markDNSForUpdate)
623
118
        self.postgresListener.register(
624
119
            "sys_dns_updates", self.queueDynamicDNSUpdate
625
120
        )
626
113
        self.postgresListener.register("sys_proxy", self.markProxyForUpdate)
121
        self.postgresListener.register("sys_proxy", self.markProxyForUpdate)
627
114
        self.postgresListener.register("sys_rbac", self.markRBACForUpdate)
122
        self.postgresListener.register("sys_rbac", self.markRBACForUpdate)
628
115
        self.postgresListener.register(
123
        self.postgresListener.register(
629
@@ -164,6 +172,21 @@ class RegionControllerService(Service):
630
164
        )
172
        )
631
165
        eventloop.restart()
173
        eventloop.restart()
632
166
174
633
175
    def queueDynamicDNSUpdate(self, channel, message):
634
176
        """
635
177
        Called when the `sys_dns_update` message is received
636
178
        and queues updates for existing domains
637
179
        """
638
180
        if message == "":
639
181
            return
640
182
641
183
        (new_updates, need_reload) = process_dns_update_notify(message)
642
184
643
185
        self._dns_requires_full_reload = (
644
186
            self._dns_requires_full_reload or need_reload
645
187
        )
646
188
        self._dns_updates += new_updates
647
189
648
167
    def startProcessing(self):
190
    def startProcessing(self):
649
168
        """Start the process looping call."""
191
        """Start the process looping call."""
650
169
        if not self.processing.running:
192
        if not self.processing.running:
651
@@ -193,10 +216,22 @@ class RegionControllerService(Service):
652
193
            if delay:
216
            if delay:
653
194
                return pause(delay)
217
                return pause(delay)
654
195
218
655
219
        def _clear_dynamic_dns_updates(d):
656
220
            self._dns_updates = []
657
221
            self._dns_requires_full_reload = False
658
222
            return d
659
223
660
196
        defers = []
224
        defers = []
661
197
        if self.needsDNSUpdate:
225
        if self.needsDNSUpdate:
662
198
            self.needsDNSUpdate = False
226
            self.needsDNSUpdate = False
664
199
            d = deferToDatabase(transactional(dns_update_all_zones))
227
            d = deferToDatabase(
665
228
                transactional(
666
229
                    dns_update_all_zones,
667
230
                ),
668
231
                dynamic_updates=self._dns_updates,
669
232
                requires_reload=self._dns_requires_full_reload,
670
233
            )
671
234
            d.addCallback(_clear_dynamic_dns_updates)
672
200
            d.addCallback(self._checkSerial)
235
            d.addCallback(self._checkSerial)
673
201
            d.addCallback(self._logDNSReload)
236
            d.addCallback(self._logDNSReload)
674
202
            # Order here matters, first needsDNSUpdate is set then pass the
237
            # Order here matters, first needsDNSUpdate is set then pass the
675
diff --git a/src/maasserver/region_script.py b/src/maasserver/region_script.py
676
index 0c87c61..7894260 100644
677
--- a/src/maasserver/region_script.py
678
+++ b/src/maasserver/region_script.py
679
@@ -42,6 +42,7 @@ def run_django(is_snap, is_devenv):
680
42
                "MAAS_DNS_CONFIG_DIR": os.path.join(snap_data, "bind"),
42
                "MAAS_DNS_CONFIG_DIR": os.path.join(snap_data, "bind"),
681
43
                "MAAS_PROXY_CONFIG_DIR": os.path.join(snap_data, "proxy"),
43
                "MAAS_PROXY_CONFIG_DIR": os.path.join(snap_data, "proxy"),
682
44
                "MAAS_SYSLOG_CONFIG_DIR": os.path.join(snap_data, "syslog"),
44
                "MAAS_SYSLOG_CONFIG_DIR": os.path.join(snap_data, "syslog"),
683
45
                "MAAS_ZONE_FILE_CONFIG_DIR": os.path.join(snap_data, "bind"),
684
45
                "MAAS_IMAGES_KEYRING_FILEPATH": (
46
                "MAAS_IMAGES_KEYRING_FILEPATH": (
685
46
                    "/snap/maas/current/usr/share/keyrings/"
47
                    "/snap/maas/current/usr/share/keyrings/"
686
47
                    "ubuntu-cloudimage-keyring.gpg"
48
                    "ubuntu-cloudimage-keyring.gpg"
687
diff --git a/src/maasserver/tests/test_region_controller.py b/src/maasserver/tests/test_region_controller.py
688
index 0995258..4f40354 100644
689
--- a/src/maasserver/tests/test_region_controller.py
690
+++ b/src/maasserver/tests/test_region_controller.py
691
@@ -69,6 +69,7 @@ class TestRegionControllerService(MAASServerTestCase):
692
69
            listener.register,
69
            listener.register,
693
70
            MockCallsMatch(
70
            MockCallsMatch(
694
71
                call("sys_dns", service.markDNSForUpdate),
71
                call("sys_dns", service.markDNSForUpdate),
695
72
                call("sys_dns_updates", service.queueDynamicDNSUpdate),
696
72
                call("sys_proxy", service.markProxyForUpdate),
73
                call("sys_proxy", service.markProxyForUpdate),
697
73
                call("sys_rbac", service.markRBACForUpdate),
74
                call("sys_rbac", service.markRBACForUpdate),
698
74
                call("sys_vault_migration", service.restartRegion),
75
                call("sys_vault_migration", service.restartRegion),
699
@@ -216,7 +217,9 @@ class TestRegionControllerService(MAASServerTestCase):
700
216
        mock_msg = self.patch(region_controller.log, "msg")
217
        mock_msg = self.patch(region_controller.log, "msg")
701
217
        service.startProcessing()
218
        service.startProcessing()
702
218
        yield service.processingDefer
219
        yield service.processingDefer
704
219
        self.assertThat(mock_dns_update_all_zones, MockCalledOnceWith())
220
        mock_dns_update_all_zones.assert_called_once_with(
705
221
            dynamic_updates=[], requires_reload=False
706
222
        )
707
220
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
223
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
708
221
        self.assertThat(
224
        self.assertThat(
709
222
            mock_msg,
225
            mock_msg,
710
@@ -258,7 +261,11 @@ class TestRegionControllerService(MAASServerTestCase):
711
258
        service.startProcessing()
261
        service.startProcessing()
712
259
        yield service.processingDefer
262
        yield service.processingDefer
713
260
        self.assertThat(
263
        self.assertThat(
715
261
            mock_dns_update_all_zones, MockCallsMatch(call(), call())
264
            mock_dns_update_all_zones,
716
265
            MockCallsMatch(
717
266
                call(dynamic_updates=[], requires_reload=False),
718
267
                call(dynamic_updates=[], requires_reload=False),
719
268
            ),
720
262
        )
269
        )
721
263
        self.assertThat(
270
        self.assertThat(
722
264
            mock_check_serial,
271
            mock_check_serial,
723
@@ -313,7 +320,9 @@ class TestRegionControllerService(MAASServerTestCase):
724
313
        mock_err = self.patch(region_controller.log, "err")
320
        mock_err = self.patch(region_controller.log, "err")
725
314
        service.startProcessing()
321
        service.startProcessing()
726
315
        yield service.processingDefer
322
        yield service.processingDefer
728
316
        self.assertThat(mock_dns_update_all_zones, MockCalledOnceWith())
323
        mock_dns_update_all_zones.assert_called_once_with(
729
324
            dynamic_updates=[], requires_reload=False
730
325
        )
731
317
        self.assertThat(
326
        self.assertThat(
732
318
            mock_err, MockCalledOnceWith(ANY, "Failed configuring DNS.")
327
            mock_err, MockCalledOnceWith(ANY, "Failed configuring DNS.")
733
319
        )
328
        )
734
@@ -400,12 +409,11 @@ class TestRegionControllerService(MAASServerTestCase):
735
400
        mock_rbacSync.return_value = None
409
        mock_rbacSync.return_value = None
736
401
        service.startProcessing()
410
        service.startProcessing()
737
402
        yield service.processingDefer
411
        yield service.processingDefer
742
403
        self.assertThat(mock_dns_update_all_zones, MockCalledOnceWith())
412
        mock_dns_update_all_zones.assert_called_once_with(
743
404
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
413
            dynamic_updates=[], requires_reload=False
740
405
        self.assertThat(
741
406
            mock_proxy_update_config, MockCalledOnceWith(reload_proxy=True)
744
407
        )
414
        )
746
408
        self.assertThat(mock_rbacSync, MockCalledOnceWith())
415
        mock_proxy_update_config.assert_called_once_with(reload_proxy=True)
747
416
        mock_rbacSync.assert_called_once()
748
409
417
749
410
    def make_soa_result(self, serial):
418
    def make_soa_result(self, serial):
750
411
        return RRHeader(
419
        return RRHeader(
751
@@ -626,7 +634,9 @@ class TestRegionControllerServiceTransactional(MAASTransactionServerTestCase):
752
626
        mock_msg = self.patch(region_controller.log, "msg")
634
        mock_msg = self.patch(region_controller.log, "msg")
753
627
        service.startProcessing()
635
        service.startProcessing()
754
628
        yield service.processingDefer
636
        yield service.processingDefer
756
629
        self.assertThat(mock_dns_update_all_zones, MockCalledOnceWith())
637
        mock_dns_update_all_zones.assert_called_once_with(
757
638
            dynamic_updates=[], requires_reload=False
758
639
        )
759
630
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
640
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
760
631
        self.assertThat(
641
        self.assertThat(
761
632
            mock_msg,
642
            mock_msg,
762
@@ -670,7 +680,9 @@ class TestRegionControllerServiceTransactional(MAASTransactionServerTestCase):
763
670
            " * %s" % publication.source
680
            " * %s" % publication.source
764
671
            for publication in reversed(publications[1:])
681
            for publication in reversed(publications[1:])
765
672
        )
682
        )
767
673
        self.assertThat(mock_dns_update_all_zones, MockCalledOnceWith())
683
        mock_dns_update_all_zones.assert_called_once_with(
768
684
            dynamic_updates=[], requires_reload=False
769
685
        )
770
674
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
686
        self.assertThat(mock_check_serial, MockCalledOnceWith(dns_result))
771
675
        self.assertThat(mock_msg, MockCalledOnceWith(expected_msg))
687
        self.assertThat(mock_msg, MockCalledOnceWith(expected_msg))
772
676
688
773
diff --git a/src/maasserver/triggers/system.py b/src/maasserver/triggers/system.py
774
index 0cf4e90..a18fe8a 100644
775
--- a/src/maasserver/triggers/system.py
776
+++ b/src/maasserver/triggers/system.py
777
@@ -1901,6 +1901,159 @@ RBAC_RPOOL_DELETE = dedent(
778
1901
)
1901
)
779
1902
1902
780
1903
1903
781
1904
# handles dynamic updates when a dnsresource is created
782
1905
# or a StaticIPAddres maps to a resource or was deleted
783
1906
def render_dns_dynamic_update_dnsresource_ip_addresses_procedure(op):
784
1907
    return dedent(
785
1908
        f"""\
786
1909
        CREATE OR REPLACE FUNCTION sys_dns_updates_dns_ip_{op}()
787
1910
        RETURNS trigger as $$
788
1911
        DECLARE
789
1912
          ip_addr text;
790
1913
          rname text;
791
1914
          rdomain_id bigint;
792
1915
          domain text;
793
1916
          ttl integer;
794
1917
        BEGIN
795
1918
          ASSERT TG_WHEN = 'AFTER', 'May only run as an AFTER trigger';
796
1919
          ASSERT TG_LEVEL <> 'STATEMENT', 'Should not be used as a STATEMENT level trigger', TG_NAME;
797
1920
          IF (TG_OP = 'INSERT' AND TG_LEVEL = 'ROW') THEN
798
1921
            SELECT host(ip) INTO ip_addr FROM maasserver_staticipaddress WHERE id=NEW.staticipaddress_id;
799
1922
            SELECT name, domain_id, COALESCE(address_ttl, 0) INTO rname, rdomain_id, ttl FROM maasserver_dnsresource WHERE id=NEW.dnsresource_id;
800
1923
            SELECT name INTO domain FROM maasserver_domain WHERE id=rdomain_id;
801
1924
            PERFORM pg_notify('sys_dns_updates', 'INSERT ' || domain || ' ' || rname || ' A ' || ttl || ' ' || ip_addr);
802
1925
          ELSIF (TG_OP = 'DELETE' AND TG_LEVEl = 'ROW') THEN
803
1926
            IF EXISTS(SELECT id FROM maasserver_dnsresource WHERE id=OLD.dnsresource_id) THEN
804
1927
              IF EXISTS(SELECT id FROM maasserver_staticipaddress WHERE id=OLD.staticipaddress_id) THEN
805
1928
                SELECT host(ip) INTO ip_addr FROM maasserver_staticipaddress WHERE id=OLD.staticipaddress_id;
806
1929
                SELECT name, domain_id INTO rname, rdomain_id FROM maasserver_dnsresource WHERE id=OLD.dnsresource_id;
807
1930
                SELECT name INTO domain FROM maasserver_domain WHERE id=rdomain_id;
808
1931
                PERFORM pg_notify('sys_dns_updates', 'DELETE ' || domain || ' ' || rname || ' A ' || ip_addr);
809
1932
              ELSE
810
1933
                SELECT name, domain_id INTO rname, rdomain_id FROM maasserver_dnsresource WHERE id=NEW.dnsresource_id;
811
1934
                SELECT name INTO domain FROM maasserver_domain WHERE id=rdomain_id;
812
1935
                PERFORM pg_notify('sys_dns_updates', 'DELETE-IP ' || domain || ' ' || rname || ' A');
813
1936
                PERFORM pg_notify('sys_dns_updates', 'DELETE-IP ' || domain || ' ' || rname || ' AAAA');
814
1937
              END IF;
815
1938
            END IF;
816
1939
          END IF;
817
1940
          RETURN NULL;
818
1941
        END;
819
1942
        $$ LANGUAGE plpgsql;
820
1943
        """
821
1944
    )
822
1945
823
1946
824
1947
# handles when ttl or name is modified or resource is deleted,
825
1948
# DNS_DYNAMIC_UPDATE_DNSRESOURCE_STATICIPADDRESS covers the case of insert
826
1949
def render_dns_dynamic_update_dnsresource_procedure(op):
827
1950
    return dedent(
828
1951
        f"""\
829
1952
        CREATE OR REPLACE FUNCTION sys_dns_updates_maasserver_dnsresource_{op}()
830
1953
        RETURNS trigger as $$
831
1954
        DECLARE
832
1955
          ip_addr text;
833
1956
          ips text[];
834
1957
          domain text;
835
1958
        BEGIN
836
1959
          ASSERT TG_WHEN = 'AFTER', 'May only run as an AFTER trigger';
837
1960
          ASSERT TG_LEVEL <> 'STATEMENT', 'Should not be used as a STATEMENT level trigger', TG_NAME;
838
1961
          IF (TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW') THEN
839
1962
            IF NEW IS DISTINCT FROM OLD THEN
840
1963
                SELECT array_agg(host(ip)) INTO ips FROM maasserver_dnsresource_ip_addresses m
841
1964
                  INNER JOIN maasserver_staticipaddress ON maasserver_staticipaddress.id=m.staticipaddress_id
842
1965
                  WHERE dnsresource_id=NEW.id;
843
1966
                SELECT name INTO domain FROM maasserver_domain WHERE id=NEW.domain_id;
844
1967
                IF array_length(ips, 1) > 0 THEN
845
1968
                    FOREACH ip_addr IN ARRAY ips
846
1969
                    LOOP
847
1970
                      IF OLD.name <> NEW.name THEN
848
1971
                        PERFORM pg_notify('sys_dns_updates', 'DELETE ' || domain || ' ' || OLD.name || ' A ' || ip_addr);
849
1972
                        PERFORM pg_notify('sys_dns_updates', 'INSERT ' || domain || ' ' || NEW.name || ' A ' || NEW.address_ttl || ' ' || ip_addr);
850
1973
                      ELSE
851
1974
                        PERFORM pg_notify('sys_dns_updates', 'UPDATE ' || domain || ' ' || NEW.name || ' A ' || NEW.address_ttl || ' ' || ip_addr);
852
1975
                      END IF;
853
1976
                    END LOOP;
854
1977
                END IF;
855
1978
            ELSE
856
1979
              RETURN NULL;
857
1980
            END IF;
858
1981
          ELSIF (TG_OP = 'DELETE' AND TG_LEVEL = 'ROW') THEN
859
1982
            SELECT name INTO domain FROM maasserver_domain WHERE id=NEW.domain_id;
860
1983
            PERFORM pg_notify('sys_dns_updates', 'DELETE ' || domain || ' ' || OLD.name || ' A');
861
1984
          END IF;
862
1985
          RETURN NULL;
863
1986
        END;
864
1987
        $$ LANGUAGE plpgsql;
865
1988
        """
866
1989
    )
867
1990
868
1991
869
1992
def render_dns_dynamic_update_dnsdata_procedure(op):
870
1993
    return dedent(
871
1994
        f"""\
872
1995
        CREATE OR REPLACE FUNCTION sys_dns_updates_maasserver_dnsdata_{op}()
873
1996
        RETURNS trigger as $$
874
1997
        DECLARE
875
1998
          rname text;
876
1999
          rdomain_id bigint;
877
2000
          domain text;
878
2001
          ttl int;
879
2002
        BEGIN
880
2003
          ASSERT TG_WHEN = 'AFTER', 'May only run as an AFTER trigger';
881
2004
          ASSERT TG_LEVEL <> 'STATEMENT', 'Should not be used as a STATEMENT level trigger', TG_NAME;
882
2005
          IF (TG_OP = 'UPDATE' AND TG_LEVEL = 'ROW') THEN
883
2006
            IF NEW IS DISTINCT FROM OLD THEN
884
2007
                PERFORM pg_notify('sys_dns_updates', 'UPDATE-DATA ' || NEW.id);
885
2008
            ELSE
886
2009
              RETURN NULL;
887
2010
            END IF;
888
2011
          ELSIF (TG_OP = 'INSERT' AND TG_LEVEL = 'ROW') THEN
889
2012
            PERFORM pg_notify('sys_dns_updates', 'INSERT-DATA ' || NEW.id);
890
2013
          ELSIF (TG_OP = 'DELETE' AND TG_LEVEL = 'ROW') THEN
891
2014
            SELECT name, domain_id INTO rname, rdomain_id from maasserver_dnsresource WHERE id=OLD.dnsresource_id;
892
2015
            SELECT name INTO domain FROM maasserver_domain WHERE id=rdomain_id;
893
2016
            PERFORM pg_notify('sys_dns_updates', 'DELETE ' || domain || ' ' || rname || ' ' || OLD.rrtype);
894
2017
          END IF;
895
2018
          RETURN NULL;
896
2019
        END;
897
2020
        $$ LANGUAGE plpgsql;
898
2021
        """
899
2022
    )
900
2023
901
2024
902
2025
def render_dns_dynamic_update_domain_procedure(op):
903
2026
    return dedent(
904
2027
        f"""\
905
2028
        CREATE OR REPLACE FUNCTION sys_dns_updates_maasserver_domain_{op}()
906
2029
        RETURNS trigger as $$
907
2030
        BEGIN
908
2031
          ASSERT TG_WHEN = 'AFTER', 'May only run as an AFTER trigger';
909
2032
          ASSERT TG_LEVEL <> 'STATEMENT', 'Should not be used as a STATEMENT level trigger', TG_NAME;
910
2033
          PERFORM pg_notify('sys_dns_updates', 'RELOAD');
911
2034
          RETURN NULL;
912
2035
        END;
913
2036
        $$ LANGUAGE plpgsql;
914
2037
        """
915
2038
    )
916
2039
917
2040
918
2041
def render_dns_dynamic_update_subnet_procedure(op):
919
2042
    return dedent(
920
2043
        f"""\
921
2044
        CREATE OR REPLACE FUNCTION sys_dns_updates_maasserver_subnet_{op}()
922
2045
        RETURNS trigger as $$
923
2046
        BEGIN
924
2047
          ASSERT TG_WHEN = 'AFTER', 'May only run as an AFTER trigger';
925
2048
          ASSERT TG_LEVEL <> 'STATEMENT', 'Should not be used as a STATEMENT level trigger', TG_NAME;
926
2049
          PERFORM pg_notify('sys_dns_updates', 'RELOAD');
927
2050
          RETURN NULL;
928
2051
        END;
929
2052
        $$ LANGUAGE plpgsql;
930
2053
        """
931
2054
    )
932
2055
933
2056
934
1904
def render_sys_proxy_procedure(proc_name, on_delete=False):
2057
def render_sys_proxy_procedure(proc_name, on_delete=False):
935
1905
    """Render a database procedure with name `proc_name` that notifies that a
2058
    """Render a database procedure with name `proc_name` that notifies that a
936
1906
    proxy update is needed.
2059
    proxy update is needed.
937
@@ -2163,3 +2316,90 @@ def register_system_triggers():
938
2163
    register_trigger(
2316
    register_trigger(
939
2164
        "maasserver_resourcepool", "sys_rbac_rpool_delete", "delete"
2317
        "maasserver_resourcepool", "sys_rbac_rpool_delete", "delete"
940
2165
    )
2318
    )
941
2319
942
2320
    register_procedure(
943
2321
        render_dns_dynamic_update_dnsresource_ip_addresses_procedure("insert")
944
2322
    )
945
2323
    register_trigger(
946
2324
        "maasserver_dnsresource_ip_addresses",
947
2325
        "sys_dns_updates_dns_ip_insert",
948
2326
        "insert",
949
2327
    )
950
2328
    register_procedure(
951
2329
        render_dns_dynamic_update_dnsresource_ip_addresses_procedure("delete")
952
2330
    )
953
2331
    register_trigger(
954
2332
        "maasserver_dnsresource_ip_addresses",
955
2333
        "sys_dns_updates_dns_ip_delete",
956
2334
        "delete",
957
2335
    )
958
2336
    register_procedure(
959
2337
        render_dns_dynamic_update_dnsresource_procedure("update")
960
2338
    )
961
2339
    register_trigger(
962
2340
        "maasserver_dnsresource",
963
2341
        "sys_dns_updates_maasserver_dnsresource_update",
964
2342
        "update",
965
2343
    )
966
2344
    register_procedure(
967
2345
        render_dns_dynamic_update_dnsresource_procedure("delete")
968
2346
    )
969
2347
    register_trigger(
970
2348
        "maasserver_dnsresource",
971
2349
        "sys_dns_updates_maasserver_dnsresource_delete",
972
2350
        "delete",
973
2351
    )
974
2352
    register_procedure(render_dns_dynamic_update_dnsdata_procedure("insert"))
975
2353
    register_trigger(
976
2354
        "maasserver_dnsdata",
977
2355
        "sys_dns_updates_maasserver_dnsdata_insert",
978
2356
        "update",
979
2357
    )
980
2358
    register_procedure(render_dns_dynamic_update_dnsdata_procedure("update"))
981
2359
    register_trigger(
982
2360
        "maasserver_dnsdata",
983
2361
        "sys_dns_updates_maasserver_dnsdata_update",
984
2362
        "update",
985
2363
    )
986
2364
    register_procedure(render_dns_dynamic_update_dnsdata_procedure("delete"))
987
2365
    register_trigger(
988
2366
        "maasserver_dnsdata",
989
2367
        "sys_dns_updates_maasserver_dnsdata_delete",
990
2368
        "delete",
991
2369
    )
992
2370
    register_procedure(render_dns_dynamic_update_domain_procedure("insert"))
993
2371
    register_trigger(
994
2372
        "maasserver_domain",
995
2373
        "sys_dns_updates_maasserver_domain_insert",
996
2374
        "insert",
997
2375
    )
998
2376
    register_procedure(render_dns_dynamic_update_domain_procedure("update"))
999
2377
    register_trigger(
1000
2378
        "maasserver_domain",
1001
2379
        "sys_dns_updates_maasserver_domain_update",
1002
2380
        "update",
1003
2381
    )
1004
2382
    register_procedure(render_dns_dynamic_update_domain_procedure("delete"))
1005
2383
    register_trigger(
1006
2384
        "maasserver_domain",
1007
2385
        "sys_dns_updates_maasserver_domain_delete",
1008
2386
        "delete",
1009
2387
    )
1010
2388
    register_procedure(render_dns_dynamic_update_subnet_procedure("insert"))
1011
2389
    register_trigger(
1012
2390
        "maasserver_subnet",
1013
2391
        "sys_dns_updates_maasserver_subnet_insert",
1014
2392
        "insert",
1015
2393
    )
1016
2394
    register_procedure(render_dns_dynamic_update_subnet_procedure("update"))
1017
2395
    register_trigger(
1018
2396
        "maasserver_subnet",
1019
2397
        "sys_dns_updates_maasserver_subnet_update",
1020
2398
        "update",
1021
2399
    )
1022
2400
    register_procedure(render_dns_dynamic_update_subnet_procedure("delete"))
1023
2401
    register_trigger(
1024
2402
        "maasserver_subnet",
1025
2403
        "sys_dns_updates_maasserver_subnet_delete",
1026
2404
        "delete",
1027
2405
    )
1028
diff --git a/src/maasserver/triggers/testing.py b/src/maasserver/triggers/testing.py
1029
index 538fbc4..551ef4d 100644
1030
--- a/src/maasserver/triggers/testing.py
1031
+++ b/src/maasserver/triggers/testing.py
1032
@@ -4,11 +4,10 @@
1033
4
"""Helper class for all tests using the `PostgresListenerService` under
4
"""Helper class for all tests using the `PostgresListenerService` under
1034
5
`maasserver.triggers.tests`."""
5
`maasserver.triggers.tests`."""
1035
6
6
1036
7
1037
8
from django.contrib.auth.models import User
7
from django.contrib.auth.models import User
1038
9
from piston3.models import Token
8
from piston3.models import Token
1039
10
from testtools.matchers import GreaterThan, Is, Not
9
from testtools.matchers import GreaterThan, Is, Not
1041
11
from twisted.internet.defer import inlineCallbacks, returnValue
10
from twisted.internet.defer import DeferredQueue, inlineCallbacks, returnValue
1042
12
11
1043
13
from maasserver.enum import INTERFACE_TYPE, NODE_TYPE
12
from maasserver.enum import INTERFACE_TYPE, NODE_TYPE
1044
14
from maasserver.listener import PostgresListenerService
13
from maasserver.listener import PostgresListenerService
1045
@@ -53,6 +52,7 @@ from maasserver.models.virtualblockdevice import VirtualBlockDevice
1046
53
from maasserver.models.vlan import VLAN
52
from maasserver.models.vlan import VLAN
1047
54
from maasserver.models.zone import Zone
53
from maasserver.models.zone import Zone
1048
55
from maasserver.testing.factory import factory, RANDOM
54
from maasserver.testing.factory import factory, RANDOM
1049
55
from maasserver.triggers import register_trigger
1050
56
from maasserver.utils.orm import reload_object, transactional
56
from maasserver.utils.orm import reload_object, transactional
1051
57
from maasserver.utils.threads import deferToDatabase
57
from maasserver.utils.threads import deferToDatabase
1052
58
from maastesting.crochet import wait_for
58
from maastesting.crochet import wait_for
1053
@@ -942,3 +942,44 @@ class RBACHelpersMixin:
1054
942
                GreaterThan(old.id),
942
                GreaterThan(old.id),
1055
943
                "RBAC sync tracking has not been modified again.",
943
                "RBAC sync tracking has not been modified again.",
1056
944
            )
944
            )
1057
945
1058
946
1059
947
class NotifyHelperMixin:
1060
948
1061
949
    channels = ()
1062
950
    channel_queues = {}
1063
951
    postgres_listener_service = None
1064
952
1065
953
    @inlineCallbacks
1066
954
    def set_service(self, listener):
1067
955
        self.postgres_listener_service = listener
1068
956
        yield self.postgres_listener_service.startService()
1069
957
1070
958
    def register_trigger(self, table, channel, ops=(), trigger=None):
1071
959
        if channel not in self.channels:
1072
960
            self.postgres_listener_service.registerChannel(channel)
1073
961
            self.postgres_listener_service.register(channel, self.listen)
1074
962
            self.channels = self.channels + (channel,)
1075
963
        for op in ops:
1076
964
            trigger = trigger or f"{channel}_{table}_{op}"
1077
965
            register_trigger(table, trigger, op)
1078
966
1079
967
    @inlineCallbacks
1080
968
    def listen(self, channel, msg):
1081
969
        if msg:
1082
970
            yield self.channel_queues[channel].put(msg)
1083
971
1084
972
    @inlineCallbacks
1085
973
    def get_notify(self, channel):
1086
974
        msg = yield self.channel_queues[channel].get()
1087
975
        return msg
1088
976
1089
977
    def start_reading(self):
1090
978
        for channel in self.channels:
1091
979
            self.channel_queues[channel] = DeferredQueue()
1092
980
        self.postgres_listener_service.startReading()
1093
981
1094
982
    def stop_reading(self):
1095
983
        for channel in self.channels:
1096
984
            del self.channel_queues[channel]
1097
985
        self.postgres_listener_service.stopReading()
1098
diff --git a/src/maasserver/triggers/tests/test_init.py b/src/maasserver/triggers/tests/test_init.py
1099
index 7b6e8ee..e4fb3ed 100644
1100
--- a/src/maasserver/triggers/tests/test_init.py
1101
+++ b/src/maasserver/triggers/tests/test_init.py
1102
@@ -70,15 +70,25 @@ class TestTriggersUsed(MAASServerTestCase):
1103
70
        "dnsdata_sys_dns_dnsdata_delete",
70
        "dnsdata_sys_dns_dnsdata_delete",
1104
71
        "dnsdata_sys_dns_dnsdata_insert",
71
        "dnsdata_sys_dns_dnsdata_insert",
1105
72
        "dnsdata_sys_dns_dnsdata_update",
72
        "dnsdata_sys_dns_dnsdata_update",
1106
73
        "dnsdata_sys_dns_updates_maasserver_dnsdata_delete",
1107
74
        "dnsdata_sys_dns_updates_maasserver_dnsdata_insert",
1108
75
        "dnsdata_sys_dns_updates_maasserver_dnsdata_update",
1109
73
        "dnspublication_sys_dns_publish",
76
        "dnspublication_sys_dns_publish",
1110
74
        "dnsresource_ip_addresses_sys_dns_dnsresource_ip_link",
77
        "dnsresource_ip_addresses_sys_dns_dnsresource_ip_link",
1111
75
        "dnsresource_ip_addresses_sys_dns_dnsresource_ip_unlink",
78
        "dnsresource_ip_addresses_sys_dns_dnsresource_ip_unlink",
1112
76
        "dnsresource_sys_dns_dnsresource_delete",
79
        "dnsresource_sys_dns_dnsresource_delete",
1113
77
        "dnsresource_sys_dns_dnsresource_insert",
80
        "dnsresource_sys_dns_dnsresource_insert",
1114
78
        "dnsresource_sys_dns_dnsresource_update",
81
        "dnsresource_sys_dns_dnsresource_update",
1115
82
        "dnsresource_sys_dns_updates_maasserver_dnsresource_update",
1116
83
        "dnsresource_sys_dns_updates_maasserver_dnsresource_delete",
1117
84
        "dnsresource_ip_addresses_sys_dns_updates_dns_ip_insert",
1118
85
        "dnsresource_ip_addresses_sys_dns_updates_dns_ip_delete",
1119
79
        "domain_sys_dns_domain_delete",
86
        "domain_sys_dns_domain_delete",
1120
80
        "domain_sys_dns_domain_insert",
87
        "domain_sys_dns_domain_insert",
1121
81
        "domain_sys_dns_domain_update",
88
        "domain_sys_dns_domain_update",
1122
89
        "domain_sys_dns_updates_maasserver_domain_delete",
1123
90
        "domain_sys_dns_updates_maasserver_domain_insert",
1124
91
        "domain_sys_dns_updates_maasserver_domain_update",
1125
82
        "interface_ip_addresses_sys_dns_nic_ip_link",
92
        "interface_ip_addresses_sys_dns_nic_ip_link",
1126
83
        "interface_ip_addresses_sys_dns_nic_ip_unlink",
93
        "interface_ip_addresses_sys_dns_nic_ip_unlink",
1127
84
        "interface_sys_dhcp_interface_update",
94
        "interface_sys_dhcp_interface_update",
1128
@@ -99,6 +109,9 @@ class TestTriggersUsed(MAASServerTestCase):
1129
99
        "staticipaddress_sys_dhcp_staticipaddress_insert",
109
        "staticipaddress_sys_dhcp_staticipaddress_insert",
1130
100
        "staticipaddress_sys_dhcp_staticipaddress_update",
110
        "staticipaddress_sys_dhcp_staticipaddress_update",
1131
101
        "staticipaddress_sys_dns_staticipaddress_update",
111
        "staticipaddress_sys_dns_staticipaddress_update",
1132
112
        "subnet_sys_dns_updates_maasserver_subnet_delete",
1133
113
        "subnet_sys_dns_updates_maasserver_subnet_insert",
1134
114
        "subnet_sys_dns_updates_maasserver_subnet_update",
1135
102
        "subnet_sys_dhcp_subnet_delete",
115
        "subnet_sys_dhcp_subnet_delete",
1136
103
        "subnet_sys_dhcp_subnet_update",
116
        "subnet_sys_dhcp_subnet_update",
1137
104
        "subnet_sys_dns_subnet_delete",
117
        "subnet_sys_dns_subnet_delete",
1138
diff --git a/src/maasserver/triggers/tests/test_system.py b/src/maasserver/triggers/tests/test_system.py
1139
index 7d646ae..d5222b4 100644
1140
--- a/src/maasserver/triggers/tests/test_system.py
1141
+++ b/src/maasserver/triggers/tests/test_system.py
1142
@@ -5,13 +5,26 @@
1143
5
from contextlib import closing
5
from contextlib import closing
1144
6
6
1145
7
from django.db import connection
7
from django.db import connection
1146
8
from twisted.internet.defer import inlineCallbacks
1147
8
9
1148
9
from maasserver.models.dnspublication import zone_serial
10
from maasserver.models.dnspublication import zone_serial
1150
10
from maasserver.testing.testcase import MAASServerTestCase
11
from maasserver.testing.factory import factory
1151
12
from maasserver.testing.testcase import (
1152
13
    MAASServerTestCase,
1153
14
    MAASTransactionServerTestCase,
1154
15
)
1155
11
from maasserver.triggers.system import register_system_triggers
16
from maasserver.triggers.system import register_system_triggers
1156
17
from maasserver.triggers.testing import (
1157
18
    NotifyHelperMixin,
1158
19
    TransactionalHelpersMixin,
1159
20
)
1160
12
from maasserver.utils.orm import psql_array
21
from maasserver.utils.orm import psql_array
1161
22
from maasserver.utils.threads import deferToDatabase
1162
23
from maastesting.crochet import wait_for
1163
13
from maastesting.matchers import MockCalledOnceWith
24
from maastesting.matchers import MockCalledOnceWith
1164
14
25
1165
26
wait_for_reactor = wait_for()
1166
27
1167
15
28
1168
16
class TestTriggers(MAASServerTestCase):
29
class TestTriggers(MAASServerTestCase):
1169
17
    def test_register_system_triggers(self):
30
    def test_register_system_triggers(self):
1170
@@ -88,3 +101,269 @@ class TestTriggers(MAASServerTestCase):
1171
88
        mock_create = self.patch(zone_serial, "create_if_not_exists")
101
        mock_create = self.patch(zone_serial, "create_if_not_exists")
1172
89
        register_system_triggers()
102
        register_system_triggers()
1173
90
        self.assertThat(mock_create, MockCalledOnceWith())
103
        self.assertThat(mock_create, MockCalledOnceWith())
1174
104
1175
105
1176
106
class TestSysDNSUpdates(
1177
107
    MAASTransactionServerTestCase, TransactionalHelpersMixin, NotifyHelperMixin
1178
108
):
1179
109
    @wait_for_reactor
1180
110
    @inlineCallbacks
1181
111
    def test_dns_dynamic_update_dnsresource_ip_addresses_insert(self):
1182
112
        listener = self.make_listener_without_delay()
1183
113
        yield self.set_service(listener)
1184
114
        domain = yield deferToDatabase(self.create_domain)
1185
115
        yield deferToDatabase(
1186
116
            self.register_trigger,
1187
117
            "maasserver_dnsresource_ip_addresses",
1188
118
            "sys_dns_updates",
1189
119
            ops=("insert",),
1190
120
            trigger="sys_dns_updates_dns_ip_insert",
1191
121
        )
1192
122
        self.start_reading()
1193
123
        try:
1194
124
            static_ip = yield deferToDatabase(self.create_staticipaddress)
1195
125
            rec = yield deferToDatabase(
1196
126
                self.create_dnsresource,
1197
127
                params={"domain": domain, "ip_addresses": [static_ip]},
1198
128
            )
1199
129
            yield self.get_notify(
1200
130
                "sys_dns_updates"
1201
131
            )  # ignore RELOAD from domain creation
1202
132
            msg = yield self.get_notify("sys_dns_updates")
1203
133
            self.assertEqual(
1204
134
                msg,
1205
135
                f"INSERT {domain.name} {rec.name} A {domain.ttl if domain.ttl else 0} {static_ip.ip}",
1206
136
            )
1207
137
        finally:
1208
138
            self.stop_reading()
1209
139
            yield self.postgres_listener_service.stopService()
1210
140
1211
141
    @wait_for_reactor
1212
142
    @inlineCallbacks
1213
143
    def test_dns_dynamic_update_dnsresource_ip_addresses_delete(self):
1214
144
        listener = self.make_listener_without_delay()
1215
145
        yield self.set_service(listener)
1216
146
        domain = yield deferToDatabase(self.create_domain)
1217
147
        static_ip = yield deferToDatabase(self.create_staticipaddress)
1218
148
        rec = yield deferToDatabase(
1219
149
            self.create_dnsresource,
1220
150
            params={"domain": domain, "ip_addresses": [static_ip]},
1221
151
        )
1222
152
        yield deferToDatabase(
1223
153
            self.register_trigger,
1224
154
            "maasserver_dnsresource_ip_addresses",
1225
155
            "sys_dns_updates",
1226
156
            ops=("delete",),
1227
157
            trigger="sys_dns_updates_dns_ip_delete",
1228
158
        )
1229
159
        self.start_reading()
1230
160
        try:
1231
161
            yield deferToDatabase(rec.delete)
1232
162
            msg = yield self.get_notify("sys_dns_updates")
1233
163
            self.assertEqual(
1234
164
                msg, f"DELETE {domain.name} {rec.name} A {static_ip.ip}"
1235
165
            )
1236
166
        finally:
1237
167
            self.stop_reading()
1238
168
            yield self.postgres_listener_service.stopService()
1239
169
1240
170
    @wait_for_reactor
1241
171
    @inlineCallbacks
1242
172
    def test_dns_dynamic_update_dnsresource_update(self):
1243
173
        listener = self.make_listener_without_delay()
1244
174
        yield self.set_service(listener)
1245
175
        domain = yield deferToDatabase(self.create_domain)
1246
176
        static_ip = yield deferToDatabase(self.create_staticipaddress)
1247
177
        rec = yield deferToDatabase(
1248
178
            self.create_dnsresource,
1249
179
            params={"domain": domain, "ip_addresses": [static_ip]},
1250
180
        )
1251
181
        yield deferToDatabase(
1252
182
            self.register_trigger,
1253
183
            "maasserver_dnsresource",
1254
184
            "sys_dns_updates",
1255
185
            ops=("update",),
1256
186
        )
1257
187
        self.start_reading()
1258
188
        try:
1259
189
            rec.address_ttl = 30
1260
190
            yield deferToDatabase(rec.save)
1261
191
            msg = yield self.get_notify("sys_dns_updates")
1262
192
            self.assertEqual(
1263
193
                msg, f"UPDATE {domain.name} {rec.name} A 30 {static_ip.ip}"
1264
194
            )
1265
195
        finally:
1266
196
            self.stop_reading()
1267
197
            yield self.postgres_listener_service.stopService()
1268
198
1269
199
    @wait_for_reactor
1270
200
    @inlineCallbacks
1271
201
    def test_dns_dynamic_update_dnsresource_delete(self):
1272
202
        listener = self.make_listener_without_delay()
1273
203
        yield self.set_service(listener)
1274
204
        domain = yield deferToDatabase(self.create_domain)
1275
205
        static_ip = yield deferToDatabase(self.create_staticipaddress)
1276
206
        rec = yield deferToDatabase(
1277
207
            self.create_dnsresource,
1278
208
            params={"domain": domain, "ip_addresses": [static_ip]},
1279
209
        )
1280
210
        yield deferToDatabase(
1281
211
            self.register_trigger,
1282
212
            "maasserver_dnsresource",
1283
213
            "sys_dns_updates",
1284
214
            ops=("delete",),
1285
215
        )
1286
216
        self.start_reading()
1287
217
        try:
1288
218
            yield deferToDatabase(rec.delete)
1289
219
            msg = yield self.get_notify("sys_dns_updates")
1290
220
            self.assertEqual(
1291
221
                msg, f"DELETE {domain.name} {rec.name} A {static_ip.ip}"
1292
222
            )
1293
223
        finally:
1294
224
            self.stop_reading()
1295
225
            yield self.postgres_listener_service.stopService()
1296
226
1297
227
    @wait_for_reactor
1298
228
    @inlineCallbacks
1299
229
    def test_dns_dynamic_update_dnsdata_update(self):
1300
230
        listener = self.make_listener_without_delay()
1301
231
        yield self.set_service(listener)
1302
232
        domain = yield deferToDatabase(self.create_domain)
1303
233
        rec = yield deferToDatabase(
1304
234
            self.create_dnsresource, params={"domain": domain}
1305
235
        )
1306
236
        yield deferToDatabase(
1307
237
            self.register_trigger,
1308
238
            "maasserver_dnsdata",
1309
239
            "sys_dns_updates",
1310
240
            ops=("update",),
1311
241
        )
1312
242
        self.start_reading()
1313
243
        try:
1314
244
            dnsdata = yield deferToDatabase(
1315
245
                self.create_dnsdata,
1316
246
                params={
1317
247
                    "dnsresource": rec,
1318
248
                    "rrtype": "TXT",
1319
249
                    "rrdata": factory.make_name(),
1320
250
                },
1321
251
            )
1322
252
            dnsdata.rrdata = factory.make_name()
1323
253
            yield deferToDatabase(dnsdata.save)
1324
254
            msg = yield self.get_notify("sys_dns_updates")
1325
255
            self.assertEqual(
1326
256
                msg,
1327
257
                f"UPDATE-DATA {dnsdata.id}",
1328
258
            )
1329
259
        finally:
1330
260
            self.stop_reading()
1331
261
            yield self.postgres_listener_service.stopService()
1332
262
1333
263
    @wait_for_reactor
1334
264
    @inlineCallbacks
1335
265
    def test_dns_dynamic_update_dnsdata_insert(self):
1336
266
        listener = self.make_listener_without_delay()
1337
267
        yield self.set_service(listener)
1338
268
        domain = yield deferToDatabase(self.create_domain)
1339
269
        rec = yield deferToDatabase(
1340
270
            self.create_dnsresource, {"domain": domain}
1341
271
        )
1342
272
        yield deferToDatabase(
1343
273
            self.register_trigger,
1344
274
            "maasserver_dnsdata",
1345
275
            "sys_dns_updates",
1346
276
            ops=("insert",),
1347
277
        )
1348
278
        self.start_reading()
1349
279
        try:
1350
280
            dnsdata = yield deferToDatabase(
1351
281
                self.create_dnsdata,
1352
282
                params={
1353
283
                    "dnsresource": rec,
1354
284
                    "rrtype": "TXT",
1355
285
                    "rrdata": factory.make_name(),
1356
286
                },
1357
287
            )
1358
288
            msg = yield self.get_notify("sys_dns_updates")
1359
289
            self.assertEqual(
1360
290
                msg,
1361
291
                f"INSERT-DATA {dnsdata.id}",
1362
292
            )
1363
293
        finally:
1364
294
            self.stop_reading()
1365
295
            yield self.postgres_listener_service.stopService()
1366
296
1367
297
    @wait_for_reactor
1368
298
    @inlineCallbacks
1369
299
    def test_dns_dynamic_update_dnsdata_delete(self):
1370
300
        listener = self.make_listener_without_delay()
1371
301
        yield self.set_service(listener)
1372
302
        domain = yield deferToDatabase(self.create_domain)
1373
303
        rec = yield deferToDatabase(
1374
304
            self.create_dnsresource, params={"domain": domain}
1375
305
        )
1376
306
        dnsdata = yield deferToDatabase(
1377
307
            self.create_dnsdata,
1378
308
            params={
1379
309
                "dnsresource": rec,
1380
310
                "rrtype": "TXT",
1381
311
                "rrdata": factory.make_name(),
1382
312
            },
1383
313
        )
1384
314
        yield deferToDatabase(
1385
315
            self.register_trigger,
1386
316
            "maasserver_dnsdata",
1387
317
            "sys_dns_updates",
1388
318
            ops=("delete",),
1389
319
        )
1390
320
        self.start_reading()
1391
321
        try:
1392
322
            yield deferToDatabase(dnsdata.delete)
1393
323
            msg = yield self.get_notify("sys_dns_updates")
1394
324
            self.assertEqual(
1395
325
                msg, f"DELETE {domain.name} {rec.name} {dnsdata.rrtype}"
1396
326
            )
1397
327
        finally:
1398
328
            self.stop_reading()
1399
329
            yield self.postgres_listener_service.stopService()
1400
330
1401
331
    @wait_for_reactor
1402
332
    @inlineCallbacks
1403
333
    def test_dns_dynamic_update_domain_reload(self):
1404
334
        listener = self.make_listener_without_delay()
1405
335
        yield self.set_service(listener)
1406
336
        yield deferToDatabase(
1407
337
            self.register_trigger,
1408
338
            "maasserver_domain",
1409
339
            "sys_dns_updates",
1410
340
            ops=("insert",),
1411
341
        )
1412
342
        self.start_reading()
1413
343
        try:
1414
344
            yield deferToDatabase(self.create_domain)
1415
345
            msg = yield self.get_notify("sys_dns_updates")
1416
346
            self.assertEqual(msg, "RELOAD")
1417
347
        finally:
1418
348
            self.stop_reading()
1419
349
            yield self.postgres_listener_service.stopService()
1420
350
1421
351
    @wait_for_reactor
1422
352
    @inlineCallbacks
1423
353
    def test_dns_dynamic_update_subnet_reload(self):
1424
354
        listener = self.make_listener_without_delay()
1425
355
        yield self.set_service(listener)
1426
356
        yield deferToDatabase(
1427
357
            self.register_trigger,
1428
358
            "maasserver_subnet",
1429
359
            "sys_dns_updates",
1430
360
            ops=("insert",),
1431
361
        )
1432
362
        self.start_reading()
1433
363
        try:
1434
364
            yield deferToDatabase(self.create_subnet)
1435
365
            msg = yield self.get_notify("sys_dns_updates")
1436
366
            self.assertEqual(msg, "RELOAD")
1437
367
        finally:
1438
368
            self.stop_reading()
1439
369
            yield self.postgres_listener_service.stopService()
1440
diff --git a/src/provisioningserver/dns/actions.py b/src/provisioningserver/dns/actions.py
1441
index 7b8b1ca..bafbac9 100644
1442
--- a/src/provisioningserver/dns/actions.py
1443
+++ b/src/provisioningserver/dns/actions.py
1444
@@ -10,14 +10,18 @@ from time import sleep
1445
10
from provisioningserver.dns.config import (
10
from provisioningserver.dns.config import (
1446
11
    DNSConfig,
11
    DNSConfig,
1447
12
    execute_rndc_command,
12
    execute_rndc_command,
1448
13
    get_nsupdate_key_path,
1449
13
    set_up_options_conf,
14
    set_up_options_conf,
1450
14
)
15
)
1451
15
from provisioningserver.logger import get_maas_logger
16
from provisioningserver.logger import get_maas_logger
1453
16
from provisioningserver.utils.shell import ExternalProcessError
17
from provisioningserver.utils.shell import ExternalProcessError, run_command
1454
17
18
1455
18
maaslog = get_maas_logger("dns")
19
maaslog = get_maas_logger("dns")
1456
19
20
1457
20
21
1458
22
MAAS_NSUPDATE_HOST = "localhost"
1459
23
1460
24
1461
21
def bind_reconfigure():
25
def bind_reconfigure():
1462
22
    """Ask BIND to reload its configuration and *new* zone files.
26
    """Ask BIND to reload its configuration and *new* zone files.
1463
23
27
1464
@@ -135,3 +139,50 @@ def bind_write_zones(zones):
1465
135
    """
139
    """
1466
136
    for zone in zones:
140
    for zone in zones:
1467
137
        zone.write_config()
141
        zone.write_config()
1468
142
1469
143
1470
144
class NSUpdateCommand:
1471
145
    executable = "nsupdate"
1472
146
1473
147
    def __init__(self, zone, updates, **kwargs):
1474
148
        self._zone = zone
1475
149
        self._updates = updates
1476
150
        self._serial = kwargs.get("serial")
1477
151
        self._zone_ttl = kwargs["ttl"]
1478
152
1479
153
    def _format_update(self, update):
1480
154
        if update.operation == "DELETE":
1481
155
            if update.answer:
1482
156
                return f"update delete {update.name} {update.rectype} {update.answer}"
1483
157
            return f"update delete {update.name} {update.rectype}"
1484
158
        ttl = update.ttl
1485
159
        if ttl is None:
1486
160
            ttl = self._zone_ttl
1487
161
        return (
1488
162
            f"update add {update.name} {ttl} {update.rectype} {update.answer}"
1489
163
        )
1490
164
1491
165
    def update(self, server_address=MAAS_NSUPDATE_HOST):
1492
166
        stdin = [f"zone {self._zone}"] + [
1493
167
            self._format_update(update) for update in self._updates
1494
168
        ]
1495
169
        if server_address:
1496
170
            stdin = [f"server {server_address}"] + stdin
1497
171
1498
172
        if self._serial:
1499
173
            stdin.append(
1500
174
                f"update add {self._zone} {self._zone_ttl} SOA {self._zone}. nobody.example.com. {self._serial} 600 1800 604800 {self._zone_ttl}"
1501
175
            )
1502
176
1503
177
        stdin.append("send\n")
1504
178
1505
179
        cmd = [self.executable, "-k", get_nsupdate_key_path()]
1506
180
        if len(self._updates) > 1:
1507
181
            cmd.append("-v")  # use TCP for bulk payloads
1508
182
1509
183
        try:
1510
184
            run_command(*cmd, stdin="\n".join(stdin).encode("ascii"))
1511
185
        except CalledProcessError as exc:
1512
186
            maaslog.error(f"dynamic update of DNS failed: {exc}")
1513
187
            ExternalProcessError.upgrade(exc)
1514
188
            raise
1515
diff --git a/src/provisioningserver/dns/commands/setup_dns.py b/src/provisioningserver/dns/commands/setup_dns.py
1516
index 65b1166..cdf4e38 100644
1517
--- a/src/provisioningserver/dns/commands/setup_dns.py
1518
+++ b/src/provisioningserver/dns/commands/setup_dns.py
1519
@@ -16,8 +16,10 @@ from textwrap import dedent
1520
16
16
1521
17
from provisioningserver.dns.config import (
17
from provisioningserver.dns.config import (
1522
18
    DNSConfig,
18
    DNSConfig,
1523
19
    set_up_nsupdate_key,
1524
19
    set_up_options_conf,
20
    set_up_options_conf,
1525
20
    set_up_rndc,
21
    set_up_rndc,
1526
22
    set_up_zone_file_dir,
1527
21
)
23
)
1528
22
24
1529
23
25
1530
@@ -49,6 +51,8 @@ def run(args, stdout=sys.stdout, stderr=sys.stderr):
1531
49
    :param stdout: Standard output stream to write to.
51
    :param stdout: Standard output stream to write to.
1532
50
    :param stderr: Standard error stream to write to.
52
    :param stderr: Standard error stream to write to.
1533
51
    """
53
    """
1534
54
    set_up_nsupdate_key()
1535
55
    set_up_zone_file_dir()
1536
52
    set_up_rndc()
56
    set_up_rndc()
1537
53
    set_up_options_conf(overwrite=not args.no_clobber)
57
    set_up_options_conf(overwrite=not args.no_clobber)
1538
54
    config = DNSConfig()
58
    config = DNSConfig()
1539
diff --git a/src/provisioningserver/dns/commands/tests/test_setup_dns.py b/src/provisioningserver/dns/commands/tests/test_setup_dns.py
1540
index dc73242..e720cff 100644
1541
--- a/src/provisioningserver/dns/commands/tests/test_setup_dns.py
1542
+++ b/src/provisioningserver/dns/commands/tests/test_setup_dns.py
1543
@@ -17,7 +17,10 @@ from provisioningserver.dns.config import (
1544
17
    MAAS_NAMED_CONF_NAME,
17
    MAAS_NAMED_CONF_NAME,
1545
18
    MAAS_RNDC_CONF_NAME,
18
    MAAS_RNDC_CONF_NAME,
1546
19
)
19
)
1548
20
from provisioningserver.dns.testing import patch_dns_config_path
20
from provisioningserver.dns.testing import (
1549
21
    patch_dns_config_path,
1550
22
    patch_zone_file_config_path,
1551
23
)
1552
21
24
1553
22
25
1554
23
class TestSetupCommand(MAASTestCase):
26
class TestSetupCommand(MAASTestCase):
1555
@@ -35,6 +38,7 @@ class TestSetupCommand(MAASTestCase):
1556
35
    def test_writes_configuration(self):
38
    def test_writes_configuration(self):
1557
36
        dns_conf_dir = self.make_dir()
39
        dns_conf_dir = self.make_dir()
1558
37
        patch_dns_config_path(self, dns_conf_dir)
40
        patch_dns_config_path(self, dns_conf_dir)
1559
41
        patch_zone_file_config_path(self, dns_conf_dir)
1560
38
        self.run_command()
42
        self.run_command()
1561
39
        named_config = os.path.join(dns_conf_dir, MAAS_NAMED_CONF_NAME)
43
        named_config = os.path.join(dns_conf_dir, MAAS_NAMED_CONF_NAME)
1562
40
        rndc_conf_path = os.path.join(dns_conf_dir, MAAS_RNDC_CONF_NAME)
44
        rndc_conf_path = os.path.join(dns_conf_dir, MAAS_RNDC_CONF_NAME)
1563
@@ -43,6 +47,7 @@ class TestSetupCommand(MAASTestCase):
1564
43
    def test_does_not_overwrite_config(self):
47
    def test_does_not_overwrite_config(self):
1565
44
        dns_conf_dir = self.make_dir()
48
        dns_conf_dir = self.make_dir()
1566
45
        patch_dns_config_path(self, dns_conf_dir)
49
        patch_dns_config_path(self, dns_conf_dir)
1567
50
        patch_zone_file_config_path(self, dns_conf_dir)
1568
46
        random_content = factory.make_string()
51
        random_content = factory.make_string()
1569
47
        factory.make_file(
52
        factory.make_file(
1570
48
            location=dns_conf_dir,
53
            location=dns_conf_dir,
1571
diff --git a/src/provisioningserver/dns/config.py b/src/provisioningserver/dns/config.py
1572
index d5409e8..5673b4a 100644
1573
--- a/src/provisioningserver/dns/config.py
1574
+++ b/src/provisioningserver/dns/config.py
1575
@@ -6,12 +6,17 @@
1576
6
6
1577
7
from collections import namedtuple
7
from collections import namedtuple
1578
8
from contextlib import contextmanager
8
from contextlib import contextmanager
1579
9
from dataclasses import dataclass
1580
9
from datetime import datetime
10
from datetime import datetime
1581
10
import errno
11
import errno
1582
12
import grp
1583
11
import os
13
import os
1584
12
import os.path
14
import os.path
1585
13
import re
15
import re
1586
14
import sys
16
import sys
1587
17
from typing import Optional
1588
18
1589
19
from netaddr import AddrFormatError, IPAddress
1590
15
20
1591
16
from provisioningserver.logger import get_maas_logger
21
from provisioningserver.logger import get_maas_logger
1592
17
from provisioningserver.utils import load_template, locate_config
22
from provisioningserver.utils import load_template, locate_config
1593
@@ -26,6 +31,63 @@ MAAS_NAMED_CONF_NAME = "named.conf.maas"
1594
26
MAAS_NAMED_CONF_OPTIONS_INSIDE_NAME = "named.conf.options.inside.maas"
31
MAAS_NAMED_CONF_OPTIONS_INSIDE_NAME = "named.conf.options.inside.maas"
1595
27
MAAS_NAMED_RNDC_CONF_NAME = "named.conf.rndc.maas"
32
MAAS_NAMED_RNDC_CONF_NAME = "named.conf.rndc.maas"
1596
28
MAAS_RNDC_CONF_NAME = "rndc.conf.maas"
33
MAAS_RNDC_CONF_NAME = "rndc.conf.maas"
1597
34
MAAS_NSUPDATE_KEY_NAME = "keys.conf.maas"
1598
35
MAAS_ZONE_FILE_DIR = "/var/lib/bind/maas"
1599
36
MAAS_ZONE_FILE_GROUP = "bind"
1600
37
1601
38
1602
39
@dataclass
1603
40
class DynamicDNSUpdate:
1604
41
    operation: str
1605
42
    name: str
1606
43
    zone: str
1607
44
    rectype: str
1608
45
    ttl: Optional[int] = None
1609
46
    subnet: Optional[str] = None  # for reverse updates
1610
47
    answer: Optional[str] = None
1611
48
1612
49
    @classmethod
1613
50
    def _is_ip(cls, answer):
1614
51
        if not answer:
1615
52
            return False
1616
53
        try:
1617
54
            IPAddress(answer)
1618
55
        except AddrFormatError:
1619
56
            return False
1620
57
        else:
1621
58
            return True
1622
59
1623
60
    @classmethod
1624
61
    def create_from_trigger(cls, **kwargs):
1625
62
        answer = kwargs.get("answer")
1626
63
        rectype = kwargs.pop("rectype")
1627
64
        if answer:
1628
65
            del kwargs["answer"]
1629
66
        # the DB trigger is unable to figure out if an IP is v6, so we do it here instead
1630
67
        if cls._is_ip(answer):
1631
68
            ip = IPAddress(answer)
1632
69
            if ip.version == 6:
1633
70
                rectype = "AAAA"
1634
71
        return cls(answer=answer, rectype=rectype, **kwargs)
1635
72
1636
73
    @classmethod
1637
74
    def as_reverse_record_update(cls, fwd_update, subnet):
1638
75
        if not fwd_update.answer_is_ip:
1639
76
            return None
1640
77
        ip = IPAddress(fwd_update.answer)
1641
78
        return cls(
1642
79
            operation=fwd_update.operation,
1643
80
            name=ip.reverse_dns,
1644
81
            zone=fwd_update.zone,
1645
82
            subnet=subnet,
1646
83
            ttl=fwd_update.ttl,
1647
84
            answer=fwd_update.name,
1648
85
            rectype="PTR",
1649
86
        )
1650
87
1651
88
    @property
1652
89
    def answer_is_ip(self):
1653
90
        return DynamicDNSUpdate._is_ip(self.answer)
1654
29
91
1655
30
92
1656
31
def get_dns_config_dir():
93
def get_dns_config_dir():
1657
@@ -40,6 +102,19 @@ def get_dns_config_dir():
1658
40
        return setting
102
        return setting
1659
41
103
1660
42
104
1661
105
def get_zone_file_config_dir():
1662
106
    """
1663
107
    Location of MAAS' zone files, separate from config files
1664
108
    so that bind can write to the location as well
1665
109
    """
1666
110
    setting = os.getenv("MAAS_ZONE_FILE_CONFIG_DIR", MAAS_ZONE_FILE_DIR)
1667
111
    if isinstance(setting, bytes):
1668
112
        fsenc = sys.getfilesystemencoding()
1669
113
        return setting.decode(fsenc)
1670
114
    else:
1671
115
        return setting
1672
116
1673
117
1674
43
def get_bind_config_dir():
118
def get_bind_config_dir():
1675
44
    """Location of bind configuration files."""
119
    """Location of bind configuration files."""
1676
45
    setting = os.getenv(
120
    setting = os.getenv(
1677
@@ -155,6 +230,30 @@ def get_rndc_conf_path():
1678
155
    return compose_config_path(MAAS_RNDC_CONF_NAME)
230
    return compose_config_path(MAAS_RNDC_CONF_NAME)
1679
156
231
1680
157
232
1681
233
def get_nsupdate_key_path():
1682
234
    return compose_config_path(MAAS_NSUPDATE_KEY_NAME)
1683
235
1684
236
1685
237
def set_up_nsupdate_key():
1686
238
    tsig = call_and_check(["tsig-keygen", "-a", "HMAC-SHA512", "maas."])
1687
239
    atomic_write(tsig, get_nsupdate_key_path(), overwrite=True, mode=0o644)
1688
240
1689
241
1690
242
def set_up_zone_file_dir():
1691
243
    p = get_zone_file_config_dir()
1692
244
    if not os.path.exists(p):
1693
245
        os.mkdir(p)
1694
246
1695
247
        uid = os.getuid()
1696
248
        gid = 0
1697
249
        group = grp.getgrnam(MAAS_ZONE_FILE_GROUP)
1698
250
        if group:
1699
251
            gid = group.gr_gid
1700
252
1701
253
        os.chown(p, uid, gid)
1702
254
        os.chmod(p, 0o775)
1703
255
1704
256
1705
158
def set_up_rndc():
257
def set_up_rndc():
1706
159
    """Writes out the two files needed to enable MAAS to use rndc commands:
258
    """Writes out the two files needed to enable MAAS to use rndc commands:
1707
160
    MAAS_RNDC_CONF_NAME and MAAS_NAMED_RNDC_CONF_NAME.
259
    MAAS_RNDC_CONF_NAME and MAAS_NAMED_RNDC_CONF_NAME.
1708
@@ -232,12 +331,16 @@ def set_up_options_conf(overwrite=True, **kwargs):
1709
232
331
1710
233
332
1711
234
def compose_config_path(filename):
333
def compose_config_path(filename):
1713
235
    """Return the full path for a DNS config or zone file."""
334
    """Return the full path for a DNS config"""
1714
236
    return os.path.join(get_dns_config_dir(), filename)
335
    return os.path.join(get_dns_config_dir(), filename)
1715
237
336
1716
238
337
1717
338
def compose_zone_file_config_path(filename):
1718
339
    return os.path.join(get_zone_file_config_dir(), filename)
1719
340
1720
341
1721
239
def compose_bind_config_path(filename):
342
def compose_bind_config_path(filename):
1723
240
    """Return the full path for a DNS config or zone file."""
343
    """Return the full path for a DNS config"""
1724
241
    return os.path.join(get_bind_config_dir(), filename)
344
    return os.path.join(get_bind_config_dir(), filename)
1725
242
345
1726
243
346
1727
@@ -309,6 +412,7 @@ class DNSConfig:
1728
309
            "forwarded_zones": self.forwarded_zones,
412
            "forwarded_zones": self.forwarded_zones,
1729
310
            "DNS_CONFIG_DIR": get_dns_config_dir(),
413
            "DNS_CONFIG_DIR": get_dns_config_dir(),
1730
311
            "named_rndc_conf_path": get_named_rndc_conf_path(),
414
            "named_rndc_conf_path": get_named_rndc_conf_path(),
1731
415
            "nsupdate_keys_conf_path": get_nsupdate_key_path(),
1732
312
            "trusted_networks": trusted_networks,
416
            "trusted_networks": trusted_networks,
1733
313
            "modified": str(datetime.today()),
417
            "modified": str(datetime.today()),
1734
314
        }
418
        }
1735
diff --git a/src/provisioningserver/dns/testing.py b/src/provisioningserver/dns/testing.py
1736
index 2415e0b..4892f7a 100644
1737
--- a/src/provisioningserver/dns/testing.py
1738
+++ b/src/provisioningserver/dns/testing.py
1739
@@ -17,6 +17,16 @@ def patch_dns_config_path(testcase, config_dir=None):
1740
17
    return config_dir
17
    return config_dir
1741
18
18
1742
19
19
1743
20
def patch_zone_file_config_path(testcase, config_dir=None):
1744
21
    """Set the DNS config dir to a temporary directory, and return its path."""
1745
22
    if config_dir is None:
1746
23
        config_dir = testcase.make_dir()
1747
24
    testcase.useFixture(
1748
25
        EnvironmentVariable("MAAS_ZONE_FILE_CONFIG_DIR", config_dir)
1749
26
    )
1750
27
    return config_dir
1751
28
1752
29
1753
20
def patch_dns_rndc_port(testcase, port):
30
def patch_dns_rndc_port(testcase, port):
1754
21
    testcase.useFixture(EnvironmentVariable("MAAS_DNS_RNDC_PORT", "%d" % port))
31
    testcase.useFixture(EnvironmentVariable("MAAS_DNS_RNDC_PORT", "%d" % port))
1755
22
32
1756
diff --git a/src/provisioningserver/dns/tests/test_actions.py b/src/provisioningserver/dns/tests/test_actions.py
1757
index 72c5b5a..1087bc0 100644
1758
--- a/src/provisioningserver/dns/tests/test_actions.py
1759
+++ b/src/provisioningserver/dns/tests/test_actions.py
1760
@@ -20,11 +20,19 @@ from maastesting.factory import factory
1761
20
from maastesting.matchers import MockCalledOnceWith, MockCallsMatch
20
from maastesting.matchers import MockCalledOnceWith, MockCallsMatch
1762
21
from maastesting.testcase import MAASTestCase
21
from maastesting.testcase import MAASTestCase
1763
22
from provisioningserver.dns import actions
22
from provisioningserver.dns import actions
1764
23
from provisioningserver.dns.actions import (
1765
24
    get_nsupdate_key_path,
1766
25
    NSUpdateCommand,
1767
26
)
1768
23
from provisioningserver.dns.config import (
27
from provisioningserver.dns.config import (
1769
28
    DynamicDNSUpdate,
1770
24
    MAAS_NAMED_CONF_NAME,
29
    MAAS_NAMED_CONF_NAME,
1771
25
    MAAS_NAMED_CONF_OPTIONS_INSIDE_NAME,
30
    MAAS_NAMED_CONF_OPTIONS_INSIDE_NAME,
1772
26
)
31
)
1774
27
from provisioningserver.dns.testing import patch_dns_config_path
32
from provisioningserver.dns.testing import (
1775
33
    patch_dns_config_path,
1776
34
    patch_zone_file_config_path,
1777
35
)
1778
28
from provisioningserver.dns.tests.test_zoneconfig import HostnameIPMapping
36
from provisioningserver.dns.tests.test_zoneconfig import HostnameIPMapping
1779
29
from provisioningserver.dns.zoneconfig import (
37
from provisioningserver.dns.zoneconfig import (
1780
30
    DNSForwardZoneConfig,
38
    DNSForwardZoneConfig,
1781
@@ -208,6 +216,7 @@ class TestConfiguration(MAASTestCase):
1782
208
        )
216
        )
1783
209
217
1784
210
    def test_bind_write_zones_writes_file(self):
218
    def test_bind_write_zones_writes_file(self):
1785
219
        zone_file_dir = patch_zone_file_config_path(self)
1786
211
        domain = factory.make_string()
220
        domain = factory.make_string()
1787
212
        network = IPNetwork("192.168.0.3/24")
221
        network = IPNetwork("192.168.0.3/24")
1788
213
        dns_ip_list = [factory.pick_ip_in_network(network)]
222
        dns_ip_list = [factory.pick_ip_in_network(network)]
1789
@@ -229,8 +238,8 @@ class TestConfiguration(MAASTestCase):
1790
229
        forward_file_name = "zone.%s" % domain
238
        forward_file_name = "zone.%s" % domain
1791
230
        reverse_file_name = "zone.0.168.192.in-addr.arpa"
239
        reverse_file_name = "zone.0.168.192.in-addr.arpa"
1792
231
        expected_files = [
240
        expected_files = [
1795
232
            join(self.dns_conf_dir, forward_file_name),
241
            join(zone_file_dir, forward_file_name),
1796
233
            join(self.dns_conf_dir, reverse_file_name),
242
            join(zone_file_dir, reverse_file_name),
1797
234
        ]
243
        ]
1798
235
        self.assertThat(expected_files, AllMatch(FileExists()))
244
        self.assertThat(expected_files, AllMatch(FileExists()))
1799
236
245
1800
@@ -270,3 +279,112 @@ class TestConfiguration(MAASTestCase):
1801
270
        self.assertThat(
279
        self.assertThat(
1802
271
            expected_options_file, FileContains(expected_options_content)
280
            expected_options_file, FileContains(expected_options_content)
1803
272
        )
281
        )
1804
282
1805
283
1806
284
class TestNSUpdateCommand(MAASTestCase):
1807
285
    def test_format_update_deletion(self):
1808
286
        domain = factory.make_name()
1809
287
        update = DynamicDNSUpdate(
1810
288
            operation="DELETE",
1811
289
            zone=domain,
1812
290
            name=f"{factory.make_name()}.{domain}",
1813
291
            rectype="A",
1814
292
        )
1815
293
        cmd = NSUpdateCommand(
1816
294
            domain,
1817
295
            [update],
1818
296
            serial=random.randint(1, 100),
1819
297
            ttl=random.randint(1, 100),
1820
298
        )
1821
299
        self.assertEqual(
1822
300
            f"update delete {update.name} A", cmd._format_update(update)
1823
301
        )
1824
302
1825
303
    def test_format_update_addition(self):
1826
304
        domain = factory.make_name()
1827
305
        update = DynamicDNSUpdate(
1828
306
            operation="INSERT",
1829
307
            zone=domain,
1830
308
            name=f"{factory.make_name()}.{domain}",
1831
309
            rectype="A",
1832
310
            answer=factory.make_ip_address(),
1833
311
        )
1834
312
        ttl = random.randint(1, 100)
1835
313
        cmd = NSUpdateCommand(
1836
314
            domain, [update], serial=random.randint(1, 100), ttl=ttl
1837
315
        )
1838
316
        self.assertEqual(
1839
317
            f"update add {update.name} {ttl} A {update.answer}",
1840
318
            cmd._format_update(update),
1841
319
        )
1842
320
1843
321
    def test_nsupdate_sends_a_single_update(self):
1844
322
        domain = factory.make_name()
1845
323
        update = DynamicDNSUpdate(
1846
324
            operation="INSERT",
1847
325
            zone=domain,
1848
326
            name=f"{factory.make_name()}.{domain}",
1849
327
            rectype="A",
1850
328
            answer=factory.make_ip_address(),
1851
329
        )
1852
330
        serial = random.randint(1, 100)
1853
331
        ttl = random.randint(1, 100)
1854
332
        cmd = NSUpdateCommand(domain, [update], serial=serial, ttl=ttl)
1855
333
        run_command = self.patch(actions, "run_command")
1856
334
        cmd.update()
1857
335
        run_command.assert_called_once_with(
1858
336
            "nsupdate",
1859
337
            "-k",
1860
338
            get_nsupdate_key_path(),
1861
339
            stdin="\n".join(
1862
340
                [
1863
341
                    "server localhost",
1864
342
                    f"zone {domain}",
1865
343
                    f"update add {update.name} {ttl} A {update.answer}",
1866
344
                    f"update add {domain} {ttl} SOA {domain}. nobody.example.com. {serial} 600 1800 604800 {ttl}",
1867
345
                    "send\n",
1868
346
                ]
1869
347
            ).encode("ascii"),
1870
348
        )
1871
349
1872
350
    def test_nsupdate_sends_a_bulk_update(self):
1873
351
        domain = factory.make_name()
1874
352
        deletions = [
1875
353
            DynamicDNSUpdate(
1876
354
                operation="DELETE",
1877
355
                zone=domain,
1878
356
                name=f"{factory.make_name()}.{domain}",
1879
357
                rectype="A",
1880
358
            )
1881
359
            for _ in range(2)
1882
360
        ]
1883
361
        additions = [
1884
362
            DynamicDNSUpdate(
1885
363
                operation="INSERT",
1886
364
                zone=domain,
1887
365
                name=f"{factory.make_name()}.{domain}",
1888
366
                rectype="A",
1889
367
                answer=factory.make_ip_address(),
1890
368
            )
1891
369
            for _ in range(2)
1892
370
        ]
1893
371
        ttl = random.randint(1, 100)
1894
372
        cmd = NSUpdateCommand(domain, deletions + additions, ttl=ttl)
1895
373
        run_command = self.patch(actions, "run_command")
1896
374
        cmd.update()
1897
375
        expected_stdin = [
1898
376
            "server localhost",
1899
377
            f"zone {domain}",
1900
378
            f"update delete {deletions[0].name} {deletions[0].rectype}",
1901
379
            f"update delete {deletions[1].name} {deletions[1].rectype}",
1902
380
            f"update add {additions[0].name} {ttl} {additions[0].rectype} {additions[0].answer}",
1903
381
            f"update add {additions[1].name} {ttl} {additions[1].rectype} {additions[1].answer}",
1904
382
            "send\n",
1905
383
        ]
1906
384
        run_command.assert_called_once_with(
1907
385
            "nsupdate",
1908
386
            "-k",
1909
387
            get_nsupdate_key_path(),
1910
388
            "-v",
1911
389
            stdin="\n".join(expected_stdin).encode("ascii"),
1912
390
        )
1913
diff --git a/src/provisioningserver/dns/tests/test_config.py b/src/provisioningserver/dns/tests/test_config.py
1914
index c29c3ca..1e02498 100644
1915
--- a/src/provisioningserver/dns/tests/test_config.py
1916
+++ b/src/provisioningserver/dns/tests/test_config.py
1917
@@ -11,7 +11,7 @@ from textwrap import dedent
1918
11
from unittest.mock import Mock, sentinel
11
from unittest.mock import Mock, sentinel
1919
12
12
1920
13
from fixtures import EnvironmentVariable
13
from fixtures import EnvironmentVariable
1922
14
from netaddr import IPNetwork
14
from netaddr import IPAddress, IPNetwork
1923
15
from testtools.matchers import (
15
from testtools.matchers import (
1924
16
    AllMatch,
16
    AllMatch,
1925
17
    Contains,
17
    Contains,
1926
@@ -40,6 +40,7 @@ from provisioningserver.dns.config import (
1927
40
    DNSConfig,
40
    DNSConfig,
1928
41
    DNSConfigDirectoryMissing,
41
    DNSConfigDirectoryMissing,
1929
42
    DNSConfigFail,
42
    DNSConfigFail,
1930
43
    DynamicDNSUpdate,
1931
43
    execute_rndc_command,
44
    execute_rndc_command,
1932
44
    extract_suggested_named_conf,
45
    extract_suggested_named_conf,
1933
45
    generate_rndc,
46
    generate_rndc,
1934
@@ -593,3 +594,75 @@ class TestDNSConfig(MAASTestCase):
1935
593
                ),
594
                ),
1936
594
            ),
595
            ),
1937
595
        )
596
        )
1938
597
1939
598
1940
599
class TestDynamicDNSUpdate(MAASTestCase):
1941
600
    def test_create_from_trigger_v4(self):
1942
601
        domain = factory.make_name()
1943
602
        update = DynamicDNSUpdate.create_from_trigger(
1944
603
            operation="INSERT",
1945
604
            zone=domain,
1946
605
            name=f"{factory.make_name()}.{domain}",
1947
606
            rectype="A",
1948
607
            answer=factory.make_ip_address(ipv6=False),
1949
608
        )
1950
609
        self.assertEqual(update.rectype, "A")
1951
610
1952
611
    def test_create_from_trigger_v6(self):
1953
612
        domain = factory.make_name()
1954
613
        update = DynamicDNSUpdate.create_from_trigger(
1955
614
            operation="INSERT",
1956
615
            zone=domain,
1957
616
            name=f"{factory.make_name()}.{domain}",
1958
617
            rectype="A",
1959
618
            answer=factory.make_ip_address(ipv6=True),
1960
619
        )
1961
620
        self.assertEqual(update.rectype, "AAAA")
1962
621
1963
622
    def test_answer_is_ip_returns_true_when_answer_is_an_ip(self):
1964
623
        domain = factory.make_name()
1965
624
        update = DynamicDNSUpdate(
1966
625
            operation="INSERT",
1967
626
            zone=domain,
1968
627
            name=f"{factory.make_name()}.{domain}",
1969
628
            rectype="A",
1970
629
            answer=factory.make_ip_address(),
1971
630
        )
1972
631
        self.assertTrue(update.answer_is_ip)
1973
632
1974
633
    def test_answer_is_ip_returns_false_when_answer_is_not_an_ip(self):
1975
634
        domain = factory.make_name()
1976
635
        update = DynamicDNSUpdate(
1977
636
            operation="INSERT",
1978
637
            zone=domain,
1979
638
            name=f"{factory.make_name()}.{domain}",
1980
639
            rectype="CNAME",
1981
640
            answer=factory.make_name(),
1982
641
        )
1983
642
        self.assertFalse(update.answer_is_ip)
1984
643
1985
644
    def test_as_reverse_record_update(self):
1986
645
        domain = factory.make_name()
1987
646
        subnet = factory.make_ip4_or_6_network()
1988
647
        fwd_update = DynamicDNSUpdate(
1989
648
            operation="INSERT",
1990
649
            zone=domain,
1991
650
            name=f"{factory.make_name()}.{domain}",
1992
651
            rectype="A",
1993
652
            answer=str(IPAddress(subnet.next())),
1994
653
        )
1995
654
        expected_rev_update = DynamicDNSUpdate(
1996
655
            operation="INSERT",
1997
656
            zone=domain,
1998
657
            name=IPAddress(fwd_update.answer).reverse_dns,
1999
658
            rectype="PTR",
2000
659
            ttl=fwd_update.ttl,
2001
660
            subnet=str(subnet),
2002
661
            answer=fwd_update.name,
2003
662
        )
2004
663
        rev_update = DynamicDNSUpdate.as_reverse_record_update(
2005
664
            fwd_update, str(subnet)
2006
665
        )
2007
666
        self.assertEqual(expected_rev_update.name, rev_update.name)
2008
667
        self.assertEqual(expected_rev_update.rectype, rev_update.rectype)
2009
668
        self.assertEqual(expected_rev_update.answer, rev_update.answer)
2010
diff --git a/src/provisioningserver/dns/tests/test_zoneconfig.py b/src/provisioningserver/dns/tests/test_zoneconfig.py
2011
index ba84efb..f97adfd 100644
2012
--- a/src/provisioningserver/dns/tests/test_zoneconfig.py
2013
+++ b/src/provisioningserver/dns/tests/test_zoneconfig.py
2014
@@ -22,8 +22,13 @@ from twisted.python.filepath import FilePath
2015
22
from maastesting.factory import factory
22
from maastesting.factory import factory
2016
23
from maastesting.matchers import MockNotCalled
23
from maastesting.matchers import MockNotCalled
2017
24
from maastesting.testcase import MAASTestCase
24
from maastesting.testcase import MAASTestCase
2020
25
from provisioningserver.dns.config import get_dns_config_dir
25
from provisioningserver.dns import actions
2021
26
from provisioningserver.dns.testing import patch_dns_config_path
26
from provisioningserver.dns.config import (
2022
27
    DynamicDNSUpdate,
2023
28
    get_nsupdate_key_path,
2024
29
    get_zone_file_config_dir,
2025
30
)
2026
31
from provisioningserver.dns.testing import patch_zone_file_config_path
2027
27
from provisioningserver.dns.zoneconfig import (
32
from provisioningserver.dns.zoneconfig import (
2028
28
    DNSForwardZoneConfig,
33
    DNSForwardZoneConfig,
2029
29
    DNSReverseZoneConfig,
34
    DNSReverseZoneConfig,
2030
@@ -100,7 +105,7 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2031
100
        domain = factory.make_name("zone")
105
        domain = factory.make_name("zone")
2032
101
        dns_zone_config = DNSForwardZoneConfig(domain)
106
        dns_zone_config = DNSForwardZoneConfig(domain)
2033
102
        self.assertEqual(
107
        self.assertEqual(
2035
103
            os.path.join(get_dns_config_dir(), "zone.%s" % domain),
108
            os.path.join(get_zone_file_config_dir(), "zone.%s" % domain),
2036
104
            dns_zone_config.zone_info[0].target_path,
109
            dns_zone_config.zone_info[0].target_path,
2037
105
        )
110
        )
2038
106
111
2039
@@ -173,7 +178,7 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2040
173
        )
178
        )
2041
174
179
2042
175
    def test_handles_slash_32_dynamic_range(self):
180
    def test_handles_slash_32_dynamic_range(self):
2044
176
        target_dir = patch_dns_config_path(self)
181
        target_dir = patch_zone_file_config_path(self)
2045
177
        domain = factory.make_string()
182
        domain = factory.make_string()
2046
178
        network = factory.make_ipv4_network()
183
        network = factory.make_ipv4_network()
2047
179
        ipv4_hostname = factory.make_name("host")
184
        ipv4_hostname = factory.make_name("host")
2048
@@ -222,7 +227,7 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2049
222
        )
227
        )
2050
223
228
2051
224
    def test_writes_dns_zone_config(self):
229
    def test_writes_dns_zone_config(self):
2053
225
        target_dir = patch_dns_config_path(self)
230
        target_dir = patch_zone_file_config_path(self)
2054
226
        domain = factory.make_string()
231
        domain = factory.make_string()
2055
227
        network = factory.make_ipv4_network()
232
        network = factory.make_ipv4_network()
2056
228
        ipv4_hostname = factory.make_name("host")
233
        ipv4_hostname = factory.make_name("host")
2057
@@ -269,7 +274,7 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2058
269
        )
274
        )
2059
270
275
2060
271
    def test_writes_dns_zone_config_with_NS_record(self):
276
    def test_writes_dns_zone_config_with_NS_record(self):
2062
272
        target_dir = patch_dns_config_path(self)
277
        target_dir = patch_zone_file_config_path(self)
2063
273
        addr_ttl = random.randint(10, 100)
278
        addr_ttl = random.randint(10, 100)
2064
274
        ns_host_name = factory.make_name("ns")
279
        ns_host_name = factory.make_name("ns")
2065
275
        dns_zone_config = DNSForwardZoneConfig(
280
        dns_zone_config = DNSForwardZoneConfig(
2066
@@ -286,7 +291,7 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2067
286
        )
291
        )
2068
287
292
2069
288
    def test_ignores_generate_directives_for_v6_dynamic_ranges(self):
293
    def test_ignores_generate_directives_for_v6_dynamic_ranges(self):
2071
289
        patch_dns_config_path(self)
294
        patch_zone_file_config_path(self)
2072
290
        domain = factory.make_string()
295
        domain = factory.make_string()
2073
291
        network = factory.make_ipv4_network()
296
        network = factory.make_ipv4_network()
2074
292
        ipv4_hostname = factory.make_name("host")
297
        ipv4_hostname = factory.make_name("host")
2075
@@ -314,7 +319,7 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2076
314
        self.assertThat(get_generate_directives, MockNotCalled())
319
        self.assertThat(get_generate_directives, MockNotCalled())
2077
315
320
2078
316
    def test_config_file_is_world_readable(self):
321
    def test_config_file_is_world_readable(self):
2080
317
        patch_dns_config_path(self)
322
        patch_zone_file_config_path(self)
2081
318
        dns_zone_config = DNSForwardZoneConfig(
323
        dns_zone_config = DNSForwardZoneConfig(
2082
319
            factory.make_string(), serial=random.randint(1, 100)
324
            factory.make_string(), serial=random.randint(1, 100)
2083
320
        )
325
        )
2084
@@ -322,6 +327,94 @@ class TestDNSForwardZoneConfig(MAASTestCase):
2085
322
        filepath = FilePath(dns_zone_config.zone_info[0].target_path)
327
        filepath = FilePath(dns_zone_config.zone_info[0].target_path)
2086
323
        self.assertTrue(filepath.getPermissions().other.read)
328
        self.assertTrue(filepath.getPermissions().other.read)
2087
324
329
2088
330
    def test_zone_file_exists(self):
2089
331
        patch_zone_file_config_path(self)
2090
332
        domain = factory.make_string()
2091
333
        network = factory.make_ipv4_network()
2092
334
        ipv4_hostname = factory.make_name("host")
2093
335
        ipv4_ip = factory.pick_ip_in_network(network)
2094
336
        ipv6_hostname = factory.make_name("host")
2095
337
        ipv6_ip = factory.make_ipv6_address()
2096
338
        ipv6_network = factory.make_ipv6_network()
2097
339
        dynamic_range = IPRange(ipv6_network.first, ipv6_network.last)
2098
340
        ttl = random.randint(10, 300)
2099
341
        mapping = {
2100
342
            ipv4_hostname: HostnameIPMapping(None, ttl, {ipv4_ip}),
2101
343
            ipv6_hostname: HostnameIPMapping(None, ttl, {ipv6_ip}),
2102
344
        }
2103
345
        dns_zone_config = DNSForwardZoneConfig(
2104
346
            domain,
2105
347
            serial=random.randint(1, 100),
2106
348
            mapping=mapping,
2107
349
            default_ttl=ttl,
2108
350
            dynamic_ranges=[dynamic_range],
2109
351
        )
2110
352
        self.patch(dns_zone_config, "get_GENERATE_directives")
2111
353
        self.assertFalse(
2112
354
            dns_zone_config.zone_file_exists(dns_zone_config.zone_info[0])
2113
355
        )
2114
356
        dns_zone_config.write_config()
2115
357
        self.assertTrue(
2116
358
            dns_zone_config.zone_file_exists(dns_zone_config.zone_info[0])
2117
359
        )
2118
360
2119
361
    def test_uses_dynamic_update_when_zone_has_been_configured_once(self):
2120
362
        patch_zone_file_config_path(self)
2121
363
        domain = factory.make_string()
2122
364
        network = factory.make_ipv4_network()
2123
365
        ipv4_hostname = factory.make_name("host")
2124
366
        ipv4_ip = factory.pick_ip_in_network(network)
2125
367
        ipv6_hostname = factory.make_name("host")
2126
368
        ipv6_ip = factory.make_ipv6_address()
2127
369
        ipv6_network = factory.make_ipv6_network()
2128
370
        dynamic_range = IPRange(ipv6_network.first, ipv6_network.last)
2129
371
        ttl = random.randint(10, 300)
2130
372
        mapping = {
2131
373
            ipv4_hostname: HostnameIPMapping(None, ttl, {ipv4_ip}),
2132
374
            ipv6_hostname: HostnameIPMapping(None, ttl, {ipv6_ip}),
2133
375
        }
2134
376
        dns_zone_config = DNSForwardZoneConfig(
2135
377
            domain,
2136
378
            serial=random.randint(1, 100),
2137
379
            mapping=mapping,
2138
380
            default_ttl=ttl,
2139
381
            dynamic_ranges=[dynamic_range],
2140
382
        )
2141
383
        self.patch(dns_zone_config, "get_GENERATE_directives")
2142
384
        run_command = self.patch(actions, "run_command")
2143
385
        dns_zone_config.write_config()
2144
386
        update = DynamicDNSUpdate.create_from_trigger(
2145
387
            operation="INSERT",
2146
388
            zone=domain,
2147
389
            name=f"{factory.make_name()}.{domain}",
2148
390
            rectype="A",
2149
391
            answer=factory.make_ip_address(),
2150
392
        )
2151
393
        new_dns_zone_config = DNSForwardZoneConfig(
2152
394
            domain,
2153
395
            serial=random.randint(1, 100),
2154
396
            mapping=mapping,
2155
397
            default_ttl=ttl,
2156
398
            dynamic_ranges=[dynamic_range],
2157
399
            dynamic_updates=[update],
2158
400
        )
2159
401
        new_dns_zone_config.write_config()
2160
402
        expected_stdin = "\n".join(
2161
403
            [
2162
404
                "server localhost",
2163
405
                f"zone {domain}",
2164
406
                f"update add {update.name} {ttl} {'A' if IPAddress(update.answer).version == 4 else 'AAAA'} {update.answer}",
2165
407
                f"update add {domain} {new_dns_zone_config.default_ttl} SOA {domain}. nobody.example.com. {new_dns_zone_config.serial} 600 1800 604800 {new_dns_zone_config.default_ttl}",
2166
408
                "send\n",
2167
409
            ]
2168
410
        )
2169
411
        run_command.assert_called_once_with(
2170
412
            "nsupdate",
2171
413
            "-k",
2172
414
            get_nsupdate_key_path(),
2173
415
            stdin=expected_stdin.encode("ascii"),
2174
416
        )
2175
417
2176
325
418
2177
326
class TestDNSReverseZoneConfig(MAASTestCase):
419
class TestDNSReverseZoneConfig(MAASTestCase):
2178
327
    """Tests for DNSReverseZoneConfig."""
420
    """Tests for DNSReverseZoneConfig."""
2179
@@ -340,7 +433,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2180
340
            ),
433
            ),
2181
341
        )
434
        )
2182
342
435
2184
343
    def test_computes_dns_config_file_paths(self):
436
    def test_computes_zone_file_config_file_paths(self):
2185
344
        domain = factory.make_name("zone")
437
        domain = factory.make_name("zone")
2186
345
        reverse_file_name = [
438
        reverse_file_name = [
2187
346
            "zone.%d.168.192.in-addr.arpa" % i for i in range(4)
439
            "zone.%d.168.192.in-addr.arpa" % i for i in range(4)
2188
@@ -350,11 +443,11 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2189
350
        )
443
        )
2190
351
        for i in range(4):
444
        for i in range(4):
2191
352
            self.assertEqual(
445
            self.assertEqual(
2193
353
                os.path.join(get_dns_config_dir(), reverse_file_name[i]),
446
                os.path.join(get_zone_file_config_dir(), reverse_file_name[i]),
2194
354
                dns_zone_config.zone_info[i].target_path,
447
                dns_zone_config.zone_info[i].target_path,
2195
355
            )
448
            )
2196
356
449
2198
357
    def test_computes_dns_config_file_paths_for_small_network(self):
450
    def test_computes_zone_file_config_file_paths_for_small_network(self):
2199
358
        domain = factory.make_name("zone")
451
        domain = factory.make_name("zone")
2200
359
        reverse_file_name = "zone.192-27.0.168.192.in-addr.arpa"
452
        reverse_file_name = "zone.192-27.0.168.192.in-addr.arpa"
2201
360
        dns_zone_config = DNSReverseZoneConfig(
453
        dns_zone_config = DNSReverseZoneConfig(
2202
@@ -362,7 +455,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2203
362
        )
455
        )
2204
363
        self.assertEqual(1, len(dns_zone_config.zone_info))
456
        self.assertEqual(1, len(dns_zone_config.zone_info))
2205
364
        self.assertEqual(
457
        self.assertEqual(
2207
365
            os.path.join(get_dns_config_dir(), reverse_file_name),
458
            os.path.join(get_zone_file_config_dir(), reverse_file_name),
2208
366
            dns_zone_config.zone_info[0].target_path,
459
            dns_zone_config.zone_info[0].target_path,
2209
367
        )
460
        )
2210
368
461
2211
@@ -620,7 +713,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2212
620
        )
713
        )
2213
621
714
2214
622
    def test_writes_dns_zone_config_with_NS_record(self):
715
    def test_writes_dns_zone_config_with_NS_record(self):
2216
623
        target_dir = patch_dns_config_path(self)
716
        target_dir = patch_zone_file_config_path(self)
2217
624
        network = factory.make_ipv4_network()
717
        network = factory.make_ipv4_network()
2218
625
        ns_host_name = factory.make_name("ns")
718
        ns_host_name = factory.make_name("ns")
2219
626
        dns_zone_config = DNSReverseZoneConfig(
719
        dns_zone_config = DNSReverseZoneConfig(
2220
@@ -637,7 +730,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2221
637
            )
730
            )
2222
638
731
2223
639
    def test_writes_reverse_dns_zone_config(self):
732
    def test_writes_reverse_dns_zone_config(self):
2225
640
        target_dir = patch_dns_config_path(self)
733
        target_dir = patch_zone_file_config_path(self)
2226
641
        domain = factory.make_string()
734
        domain = factory.make_string()
2227
642
        ns_host_name = factory.make_name("ns")
735
        ns_host_name = factory.make_name("ns")
2228
643
        network = IPNetwork("192.168.0.1/22")
736
        network = IPNetwork("192.168.0.1/22")
2229
@@ -676,7 +769,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2230
676
            )
769
            )
2231
677
770
2232
678
    def test_writes_reverse_dns_zone_config_for_small_network(self):
771
    def test_writes_reverse_dns_zone_config_for_small_network(self):
2234
679
        target_dir = patch_dns_config_path(self)
772
        target_dir = patch_zone_file_config_path(self)
2235
680
        domain = factory.make_string()
773
        domain = factory.make_string()
2236
681
        ns_host_name = factory.make_name("ns")
774
        ns_host_name = factory.make_name("ns")
2237
682
        network = IPNetwork("192.168.0.1/26")
775
        network = IPNetwork("192.168.0.1/26")
2238
@@ -710,7 +803,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2239
710
        )
803
        )
2240
711
804
2241
712
    def test_ignores_generate_directives_for_v6_dynamic_ranges(self):
805
    def test_ignores_generate_directives_for_v6_dynamic_ranges(self):
2243
713
        patch_dns_config_path(self)
806
        patch_zone_file_config_path(self)
2244
714
        domain = factory.make_string()
807
        domain = factory.make_string()
2245
715
        network = IPNetwork("192.168.0.1/22")
808
        network = IPNetwork("192.168.0.1/22")
2246
716
        dynamic_network = IPNetwork("%s/64" % factory.make_ipv6_address())
809
        dynamic_network = IPNetwork("%s/64" % factory.make_ipv6_address())
2247
@@ -729,7 +822,7 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2248
729
        self.assertThat(get_generate_directives, MockNotCalled())
822
        self.assertThat(get_generate_directives, MockNotCalled())
2249
730
823
2250
731
    def test_reverse_config_file_is_world_readable(self):
824
    def test_reverse_config_file_is_world_readable(self):
2252
732
        patch_dns_config_path(self)
825
        patch_zone_file_config_path(self)
2253
733
        dns_zone_config = DNSReverseZoneConfig(
826
        dns_zone_config = DNSReverseZoneConfig(
2254
734
            factory.make_string(),
827
            factory.make_string(),
2255
735
            serial=random.randint(1, 100),
828
            serial=random.randint(1, 100),
2256
@@ -740,6 +833,61 @@ class TestDNSReverseZoneConfig(MAASTestCase):
2257
740
            filepath = FilePath(tgt)
833
            filepath = FilePath(tgt)
2258
741
            self.assertTrue(filepath.getPermissions().other.read)
834
            self.assertTrue(filepath.getPermissions().other.read)
2259
742
835
2260
836
    def test_dynamic_update_when_zone_file_exists(self):
2261
837
        patch_zone_file_config_path(self)
2262
838
        domain = factory.make_string()
2263
839
        network = IPNetwork("10.0.0.0/24")
2264
840
        ip1 = factory.pick_ip_in_network(network)
2265
841
        ip2 = factory.pick_ip_in_network(network)
2266
842
        hostname1 = f"{factory.make_string()}.{domain}"
2267
843
        hostname2 = f"{factory.make_string()}.{domain}"
2268
844
        fwd_updates = [
2269
845
            DynamicDNSUpdate(
2270
846
                operation="INSERT",
2271
847
                zone=domain,
2272
848
                name=hostname1,
2273
849
                rectype="A",
2274
850
                answer=ip1,
2275
851
            ),
2276
852
            DynamicDNSUpdate(
2277
853
                operation="INSERT",
2278
854
                zone=domain,
2279
855
                name=hostname2,
2280
856
                rectype="A",
2281
857
                answer=ip2,
2282
858
            ),
2283
859
        ]
2284
860
        rev_updates = [
2285
861
            DynamicDNSUpdate.as_reverse_record_update(update, str(network))
2286
862
            for update in fwd_updates
2287
863
        ]
2288
864
        zone = DNSReverseZoneConfig(
2289
865
            domain,
2290
866
            serial=random.randint(1, 100),
2291
867
            network=network,
2292
868
            dynamic_updates=rev_updates,
2293
869
        )
2294
870
        run_command = self.patch(actions, "run_command")
2295
871
        zone.write_config()
2296
872
        zone.write_config()
2297
873
        expected_stdin = "\n".join(
2298
874
            [
2299
875
                "server localhost",
2300
876
                "zone 0.0.10.in-addr.arpa",
2301
877
                f"update add {IPAddress(ip1).reverse_dns} {zone.default_ttl} PTR {hostname1}",
2302
878
                f"update add {IPAddress(ip2).reverse_dns} {zone.default_ttl} PTR {hostname2}",
2303
879
                f"update add 0.0.10.in-addr.arpa {zone.default_ttl} SOA 0.0.10.in-addr.arpa. nobody.example.com. {zone.serial} 600 1800 604800 {zone.default_ttl}",
2304
880
                "send\n",
2305
881
            ]
2306
882
        )
2307
883
        run_command.assert_called_once_with(
2308
884
            "nsupdate",
2309
885
            "-k",
2310
886
            get_nsupdate_key_path(),
2311
887
            "-v",
2312
888
            stdin=expected_stdin.encode("ascii"),
2313
889
        )
2314
890
2315
743
891
2316
744
class TestDNSReverseZoneConfig_GetGenerateDirectives(MAASTestCase):
892
class TestDNSReverseZoneConfig_GetGenerateDirectives(MAASTestCase):
2317
745
    """Tests for `DNSReverseZoneConfig.get_GENERATE_directives()`."""
893
    """Tests for `DNSReverseZoneConfig.get_GENERATE_directives()`."""
2318
diff --git a/src/provisioningserver/dns/zoneconfig.py b/src/provisioningserver/dns/zoneconfig.py
2319
index d393818..eb28986 100644
2320
--- a/src/provisioningserver/dns/zoneconfig.py
2321
+++ b/src/provisioningserver/dns/zoneconfig.py
2322
@@ -6,12 +6,14 @@
2323
6
6
2324
7
from datetime import datetime
7
from datetime import datetime
2325
8
from itertools import chain
8
from itertools import chain
2326
9
import os
2327
9
10
2328
10
from netaddr import IPAddress, IPNetwork, spanning_cidr
11
from netaddr import IPAddress, IPNetwork, spanning_cidr
2329
11
from netaddr.core import AddrFormatError
12
from netaddr.core import AddrFormatError
2330
12
13
2331
14
from provisioningserver.dns.actions import NSUpdateCommand
2332
13
from provisioningserver.dns.config import (
15
from provisioningserver.dns.config import (
2334
14
    compose_config_path,
16
    compose_zone_file_config_path,
2335
15
    render_dns_template,
17
    render_dns_template,
2336
16
    report_missing_config_dir,
18
    report_missing_config_dir,
2337
17
)
19
)
2338
@@ -115,7 +117,9 @@ class DomainInfo:
2339
115
        self.subnetwork = subnetwork
117
        self.subnetwork = subnetwork
2340
116
        self.zone_name = zone_name
118
        self.zone_name = zone_name
2341
117
        if target_path is None:
119
        if target_path is None:
2343
118
            self.target_path = compose_config_path("zone.%s" % zone_name)
120
            self.target_path = compose_zone_file_config_path(
2344
121
                "zone.%s" % zone_name
2345
122
            )
2346
119
        else:
123
        else:
2347
120
            self.target_path = target_path
124
            self.target_path = target_path
2348
121
125
2349
@@ -140,9 +144,12 @@ class DomainConfigBase:
2350
140
        self.ns_host_name = kwargs.pop("ns_host_name", None)
144
        self.ns_host_name = kwargs.pop("ns_host_name", None)
2351
141
        self.serial = serial
145
        self.serial = serial
2352
142
        self.zone_info = zone_info
146
        self.zone_info = zone_info
2354
143
        self.target_base = compose_config_path("zone")
147
        self.target_base = compose_zone_file_config_path("zone")
2355
144
        self.default_ttl = kwargs.pop("default_ttl", 30)
148
        self.default_ttl = kwargs.pop("default_ttl", 30)
2356
145
        self.ns_ttl = kwargs.pop("ns_ttl", self.default_ttl)
149
        self.ns_ttl = kwargs.pop("ns_ttl", self.default_ttl)
2357
150
        self.requires_reload = False
2358
151
        self._dynamic_updates = kwargs.pop("dynamic_updates", [])
2359
152
        self.force_config_write = kwargs.pop("force_config_write", False)
2360
146
153
2361
147
    def make_parameters(self):
154
    def make_parameters(self):
2362
148
        """Return a dict of the common template parameters."""
155
        """Return a dict of the common template parameters."""
2363
@@ -155,6 +162,27 @@ class DomainConfigBase:
2364
155
            "ns_host_name": self.ns_host_name,
162
            "ns_host_name": self.ns_host_name,
2365
156
        }
163
        }
2366
157
164
2367
165
    def zone_file_exists(self, zone_info):
2368
166
        try:
2369
167
            os.stat(zone_info.target_path)
2370
168
        except FileNotFoundError:
2371
169
            return False
2372
170
        else:
2373
171
            return True
2374
172
2375
173
    def dynamic_update(self, zone_info):
2376
174
        nsupdate = NSUpdateCommand(
2377
175
            zone_info.zone_name,
2378
176
            [
2379
177
                update
2380
178
                for update in self._dynamic_updates
2381
179
                if update.zone == zone_info.zone_name or update.subnet
2382
180
            ],
2383
181
            serial=self.serial,
2384
182
            ttl=self.default_ttl,
2385
183
        )
2386
184
        nsupdate.update()
2387
185
2388
158
    @classmethod
186
    @classmethod
2389
159
    def write_zone_file(cls, output_file, *parameters):
187
    def write_zone_file(cls, output_file, *parameters):
2390
160
        """Write a zone file based on the zone file template.
188
        """Write a zone file based on the zone file template.
2391
@@ -292,22 +320,29 @@ class DNSForwardZoneConfig(DomainConfigBase):
2392
292
                    if dynamic_range.version == 4
320
                    if dynamic_range.version == 4
2393
293
                )
321
                )
2394
294
            )
322
            )
2403
295
            self.write_zone_file(
323
            if not self.force_config_write and self.zone_file_exists(zi):
2404
296
                zi.target_path,
324
                if len(self._dynamic_updates) > 0:
2405
297
                self.make_parameters(),
325
                    self.dynamic_update(zi)
2406
298
                {
326
            else:
2407
299
                    "mappings": {
327
                self.requires_reload = True
2408
300
                        "A": self.get_A_mapping(self._mapping, self._ipv4_ttl),
328
                self.write_zone_file(
2409
301
                        "AAAA": self.get_AAAA_mapping(
329
                    zi.target_path,
2410
302
                            self._mapping, self._ipv6_ttl
330
                    self.make_parameters(),
2411
331
                    {
2412
332
                        "mappings": {
2413
333
                            "A": self.get_A_mapping(
2414
334
                                self._mapping, self._ipv4_ttl
2415
335
                            ),
2416
336
                            "AAAA": self.get_AAAA_mapping(
2417
337
                                self._mapping, self._ipv6_ttl
2418
338
                            ),
2419
339
                        },
2420
340
                        "other_mapping": enumerate_rrset_mapping(
2421
341
                            self._other_mapping
2422
303
                        ),
342
                        ),
2423
343
                        "generate_directives": {"A": generate_directives},
2424
304
                    },
344
                    },
2431
305
                    "other_mapping": enumerate_rrset_mapping(
345
                )
2426
306
                        self._other_mapping
2427
307
                    ),
2428
308
                    "generate_directives": {"A": generate_directives},
2429
309
                },
2430
310
            )
2432
311
346
2433
312
347
2434
313
class DNSReverseZoneConfig(DomainConfigBase):
348
class DNSReverseZoneConfig(DomainConfigBase):
2435
@@ -575,21 +610,28 @@ class DNSReverseZoneConfig(DomainConfigBase):
2436
575
                    if dynamic_range.version == 4
610
                    if dynamic_range.version == 4
2437
576
                )
611
                )
2438
577
            )
612
            )
2454
578
            self.write_zone_file(
613
            if not self.force_config_write and self.zone_file_exists(zi):
2455
579
                zi.target_path,
614
                if len(self._dynamic_updates) > 0:
2456
580
                self.make_parameters(),
615
                    self.dynamic_update(zi)
2457
581
                {
616
            else:
2458
582
                    "mappings": {
617
                self.requires_reload = True
2459
583
                        "PTR": self.get_PTR_mapping(
618
                self.write_zone_file(
2460
584
                            self._mapping, zi.subnetwork
619
                    zi.target_path,
2461
585
                        )
620
                    self.make_parameters(),
2462
586
                    },
621
                    {
2463
587
                    "other_mapping": [],
622
                        "mappings": {
2464
588
                    "generate_directives": {
623
                            "PTR": self.get_PTR_mapping(
2465
589
                        "PTR": generate_directives,
624
                                self._mapping, zi.subnetwork
2466
590
                        "CNAME": self.get_rfc2317_GENERATE_directives(
625
                            )
2467
591
                            zi.subnetwork, self._rfc2317_ranges, self.domain
626
                        },
2468
592
                        ),
627
                        "other_mapping": [],
2469
628
                        "generate_directives": {
2470
629
                            "PTR": generate_directives,
2471
630
                            "CNAME": self.get_rfc2317_GENERATE_directives(
2472
631
                                zi.subnetwork,
2473
632
                                self._rfc2317_ranges,
2474
633
                                self.domain,
2475
634
                            ),
2476
635
                        },
2477
593
                    },
636
                    },
2480
594
                },
637
                )
2479
595
            )
2481
diff --git a/src/provisioningserver/templates/dns/named.conf.template b/src/provisioningserver/templates/dns/named.conf.template
2482
index f0f9841..7217ca8 100644
2483
--- a/src/provisioningserver/templates/dns/named.conf.template
2484
+++ b/src/provisioningserver/templates/dns/named.conf.template
2485
@@ -1,4 +1,5 @@
2486
1
include "{{named_rndc_conf_path}}";
1
include "{{named_rndc_conf_path}}";
2487
2
include "{{nsupdate_keys_conf_path}}";
2488
2
3
2489
3
# Authoritative Zone declarations.
4
# Authoritative Zone declarations.
2490
4
{{for zone in zones}}
5
{{for zone in zones}}
2491
@@ -6,6 +7,9 @@ include "{{named_rndc_conf_path}}";
2492
6
zone "{{zoneinfo.zone_name}}" {
7
zone "{{zoneinfo.zone_name}}" {
2493
7
    type master;
8
    type master;
2494
8
    file "{{zoneinfo.target_path}}";
9
    file "{{zoneinfo.target_path}}";
2495
10
    allow-update {
2496
11
        key maas.;
2497
12
    };
2498
9
};
13
};
2499
10
{{endfor}}
14
{{endfor}}
2500
11
{{endfor}}
15
{{endfor}}
Status:	Merged
Approved by:	Christian Grabowski on 2022-11-17
Approved revision:	a1306793412e4e2391470d984523214c06ed4544
Merge reported by:	MAAS Lander
Merged at revision:	not available
Proposed branch:	~cgrabowski/maas:update_dns_via_nsupdate
Merge into:	maas:master
Diff against target:	2500 lines (+1626/-87) 22 files modified debian/maas-region-api.dirs (+1/-0) debian/maas-region-api.postinst (+5/-0) src/maasserver/dns/config.py (+162/-10) src/maasserver/dns/tests/test_config.py (+149/-1) src/maasserver/dns/zonegenerator.py (+55/-2) src/maasserver/region_controller.py (+37/-2) src/maasserver/region_script.py (+1/-0) src/maasserver/tests/test_region_controller.py (+22/-10) src/maasserver/triggers/system.py (+240/-0) src/maasserver/triggers/testing.py (+43/-2) src/maasserver/triggers/tests/test_init.py (+13/-0) src/maasserver/triggers/tests/test_system.py (+280/-1) src/provisioningserver/dns/actions.py (+52/-1) src/provisioningserver/dns/commands/setup_dns.py (+4/-0) src/provisioningserver/dns/commands/tests/test_setup_dns.py (+6/-1) src/provisioningserver/dns/config.py (+106/-2) src/provisioningserver/dns/testing.py (+10/-0) src/provisioningserver/dns/tests/test_actions.py (+121/-3) src/provisioningserver/dns/tests/test_config.py (+74/-1) src/provisioningserver/dns/tests/test_zoneconfig.py (+165/-17) src/provisioningserver/dns/zoneconfig.py (+76/-34) src/provisioningserver/templates/dns/named.conf.template (+4/-0)
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
MAAS Lander	2022-11-15	Approve on 2022-11-17
Alexsander de Souza	2022-11-15	Approve on 2022-11-16
Review via email: mp+433050@code.launchpad.net