def test_dns_update_all_zones_passes_reload_retry_parameter(self):
self.patch(settings, "DNS_CONNECT", True)
bind_reload_with_retries = self.patch_autospec(
dns_config_module, "bind_reload_with_retries")
dns_update_all_zones(reload_retry=True)
self.assertThat(bind_reload_with_retries,
MockCalledOnceWith(timeout=2))
def test_bind_configuration_includes_ipv6_zone(self):
self.patch(settings, 'DNS_CONNECT', True)
network = factory.make_ipv6_network(slash=random.randint(118, 125))
subnet = factory.make_Subnet(cidr=str(network.cidr))
node, static = self.create_node_with_static_ip(subnet=subnet)
dns_update_all_zones()
self.assertDNSMatches(
node.hostname, node.domain.name, static.ip, version=6)
def test_dns_update_all_zones_includes_internal_domain(self):
self.patch(settings, 'DNS_CONNECT', True)
rack, static = self.create_rack_with_static_ip()
factory.make_RegionRackRPCConnection(rack)
dns_update_all_zones()
resource_name = get_resource_name_for_subnet(static.subnet)
self.assertDNSMatches(
resource_name, Config.objects.get_config('maas_internal_domain'),
static.ip, reverse=False)
def test_dns_update_all_zones_writes_trusted_networks_parameter(self):
self.patch(settings, 'DNS_CONNECT', True)
trusted_network = factory.make_ipv4_address()
get_trusted_networks_patch = self.patch(dns_config_module,
'get_trusted_networks')
get_trusted_networks_patch.return_value = [trusted_network]
dns_update_all_zones()
self.assertThat(compose_config_path(DNSConfig.target_file_name),
FileContains(matcher=Contains(trusted_network)))
def test_dns_update_all_zones_writes_trusted_networks_params_extra(self):
self.patch(settings, 'DNS_CONNECT', True)
extra_trusted_network = factory.make_ipv6_network()
get_trusted_acls_patch = self.patch(
dns_config_module, 'get_trusted_acls')
get_trusted_acls_patch.return_value = [extra_trusted_network.cidr]
dns_update_all_zones()
self.assertThat(
compose_config_path(DNSConfig.target_file_name),
FileContains(matcher=Contains(str(extra_trusted_network))))
def test_dns_update_all_zones_passes_upstream_dns_parameter(self):
self.patch(settings, 'DNS_CONNECT', True)
random_ip = factory.make_ipv4_address()
Config.objects.set_config("upstream_dns", random_ip)
bind_write_options = self.patch_autospec(
dns_config_module, "bind_write_options")
dns_update_all_zones()
self.assertThat(
bind_write_options,
MockCalledOnceWith(
dnssec_validation='auto', upstream_dns=[random_ip]))
def test_dnsresources_are_in_the_dns(self):
self.patch(settings, "DNS_CONNECT", True)
domain = factory.make_Domain()
subnet = factory.make_ipv4_Subnet_with_IPRanges()
dynamic_range = subnet.get_dynamic_ranges()[0]
ip = factory.pick_ip_in_IPRange(dynamic_range)
ip_obj = factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.USER_RESERVED, ip=ip, subnet=subnet)
rrname = factory.make_name("label")
dnsrr = factory.make_DNSResource(name=rrname,
domain=domain,
ip_addresses=[ip_obj])
dns_update_all_zones()
self.assertDNSMatches(dnsrr.name, domain.name, ip_obj.ip)
def test_bind_configuration_includes_dynamic_ips_of_deployed_nodes(self):
self.patch(settings, 'DNS_CONNECT', True)
subnet = factory.make_ipv4_Subnet_with_IPRanges()
node = factory.make_Node(
interface=True, status=NODE_STATUS.DEPLOYED)
nic = node.get_boot_interface()
# Get an IP in the dynamic range.
dynamic_range = subnet.get_dynamic_ranges()[0]
ip = factory.pick_ip_in_IPRange(dynamic_range)
ip_obj = factory.make_StaticIPAddress(
alloc_type=IPADDRESS_TYPE.DISCOVERED, ip=ip,
subnet=subnet, interface=nic)
dns_update_all_zones()
self.assertDNSMatches(node.hostname, node.domain.name, ip_obj.ip)
def test_dns_config_has_NS_record(self):
self.patch(settings, "DNS_CONNECT", True)
ip = factory.make_ipv4_address()
with RegionConfiguration.open_for_update() as config:
config.maas_url = "http://%s/" % ip
domain = factory.make_Domain()
node, static = self.create_node_with_static_ip(domain=domain)
dns_update_all_zones()
# Creating the domain triggered writing the zone file and updating the
# DNS.
self.dns_wait_soa(domain.name)
# Get the NS record for the zone 'domain.name'.
ns_record = dig_call(port=self.bind.config.port,
commands=[domain.name, "NS", "+short"])
self.assertGreater(len(ns_record), 0, "No NS record for domain.name.")
# Resolve that hostname.
self.dns_wait_soa(ns_record)
ip_of_ns_record = dig_call(port=self.bind.config.port,
commands=[ns_record, "+short"])
self.assertEqual(ip, ip_of_ns_record)
def test_dns_update_all_zones_includes_multiple_racks(self):
self.patch(settings, "DNS_CONNECT", True)
rack1, static1 = self.create_rack_with_static_ip()
factory.make_RegionRackRPCConnection(rack1)
rack2, static2 = self.create_rack_with_static_ip(subnet=static1.subnet)
factory.make_RegionRackRPCConnection(rack2)
dns_update_all_zones()
resource_name = get_resource_name_for_subnet(static1.subnet)
self.assertDNSMatches(
resource_name,
Config.objects.get_config("maas_internal_domain"),
static1.ip,
reverse=False,
)
self.assertDNSMatches(
resource_name,
Config.objects.get_config("maas_internal_domain"),
static2.ip,
reverse=False,
)
def test_dns_update_all_zones_returns_serial_and_domains(self):
self.patch(settings, 'DNS_CONNECT', True)
domain = factory.make_Domain()
# These domains should not show up. Just to test we create them.
for _ in range(3):
factory.make_Domain(authoritative=False)
node, static = self.create_node_with_static_ip(domain=domain)
fake_serial = random.randint(1, 1000)
self.patch(
dns_config_module,
"current_zone_serial").return_value = fake_serial
serial, reloaded, domains = dns_update_all_zones()
self.assertThat(serial, Equals(fake_serial))
self.assertThat(reloaded, Is(True))
self.assertThat(domains, MatchesSetwise(*[
Equals(domain.name)
for domain in Domain.objects.filter(authoritative=True)
]))
def test_dns_update_all_zones_loads_full_dns_config(self):
self.patch(settings, "DNS_CONNECT", True)
node, static = self.create_node_with_static_ip()
dns_update_all_zones()
self.assertDNSMatches(node.hostname, node.domain.name, static.ip)
