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