def get_dynamic_maasipset(self, exclude_ip_ranges: list = None):
if exclude_ip_ranges is None:
exclude_ip_ranges = []
dynamic_ranges = MAASIPSet(iprange.get_MAASIPRange()
for iprange in self.get_dynamic_ranges()
if iprange not in exclude_ip_ranges)
return dynamic_ranges
def get_dynamic_maasipset(self, exclude_ip_ranges: list = None):
if exclude_ip_ranges is None:
exclude_ip_ranges = []
dynamic_ranges = MAASIPSet(iprange.get_MAASIPRange()
for iprange in self.iprange_set.all()
if iprange.type == IPRANGE_TYPE.DYNAMIC
and iprange not in exclude_ip_ranges)
return dynamic_ranges
def get_reserved_maasipset(self, exclude_ip_ranges: list = None):
if exclude_ip_ranges is None:
exclude_ip_ranges = []
reserved_ranges = MAASIPSet(iprange.get_MAASIPRange()
for iprange in self.iprange_set.all()
if iprange.type == IPRANGE_TYPE.RESERVED
and iprange not in exclude_ip_ranges)
return reserved_ranges
def convert_static_ipranges_to_reserved(IPRange, subnet, ranges, created_time,
range_description):
unreserved_range_set = MAASIPSet(ranges)
unreserved_ranges = unreserved_range_set.get_unused_ranges(
subnet.cidr, purpose="reserved")
for iprange in unreserved_ranges:
start_ip = str(IPAddress(iprange.first))
end_ip = str(IPAddress(iprange.last))
IPRange.objects.get_or_create(
created=created_time,
updated=datetime.now(),
subnet=subnet,
start_ip=start_ip,
end_ip=end_ip,
type=IPRANGE_TYPE.RESERVED,
comment="Migrated from static range: %s on %s." %
(range_description, subnet.cidr))
def get_maasipset_for_neighbours(self) -> MAASIPSet:
"""Return the observed neighbours in this subnet.
:return: MAASIPSet of neighbours (with the "neighbour" purpose).
"""
# Circular imports.
from maasserver.models import Discovery
# Note: we only need unknown IP addresses here, because the known
# IP addresses should already be covered by get_ipranges_in_use().
neighbours = Discovery.objects.filter(subnet=self).by_unknown_ip()
neighbour_set = {
make_iprange(neighbour.ip, purpose="neighbour")
for neighbour in neighbours
}
return MAASIPSet(neighbour_set)
def get_ipranges_in_use(
self,
exclude_addresses: IPAddressExcludeList = None,
ranges_only: bool = False,
include_reserved: bool = True,
with_neighbours: bool = False,
ignore_discovered_ips: bool = False,
exclude_ip_ranges: list = None,
cached_staticroutes: list = None,
) -> MAASIPSet:
"""Returns a `MAASIPSet` of `MAASIPRange` objects which are currently
in use on this `Subnet`.
:param exclude_addresses: Additional addresses to consider "in use".
:param ignore_discovered_ips: DISCOVERED addresses are not "in use".
:param ranges_only: if True, filters out gateway IPs, static routes,
DNS servers, and `exclude_addresses`.
:param with_neighbours: If True, includes addresses learned from
neighbour observation.
"""
if exclude_addresses is None:
exclude_addresses = []
ranges = set()
network = self.get_ipnetwork()
if network.version == 6:
# For most IPv6 networks, automatically reserve the range:
# ::1 - ::ffff:ffff
# We expect the administrator will be using ::1 through ::ffff.
# We plan to reserve ::1:0 through ::ffff:ffff for use by MAAS,
# so that we can allocate addresses in the form:
# ::<node>:<child>
# For now, just make sure IPv6 addresses are allocated from
# *outside* both ranges, so that they won't conflict with addresses
# reserved from this scheme in the future.
first = str(IPAddress(network.first))
first_plus_one = str(IPAddress(network.first + 1))
second = str(IPAddress(network.first + 0xFFFFFFFF))
if network.prefixlen == 64:
ranges |= {
make_iprange(first_plus_one, second, purpose="reserved")
}
# Reserve the subnet router anycast address, except for /127 and
# /128 networks. (See RFC 6164, and RFC 4291 section 2.6.1.)
if network.prefixlen < 127:
ranges |= {
make_iprange(first, first, purpose="rfc-4291-2.6.1")
}
if not ranges_only:
if (self.gateway_ip is not None and self.gateway_ip != ""
and self.gateway_ip in network):
ranges |= {make_iprange(self.gateway_ip, purpose="gateway-ip")}
if self.dns_servers is not None:
ranges |= set(
make_iprange(server, purpose="dns-server")
for server in self.dns_servers if server in network)
if cached_staticroutes is not None:
static_routes = [
static_route for static_route in cached_staticroutes
if static_route.source == self
]
else:
static_routes = StaticRoute.objects.filter(source=self)
for static_route in static_routes:
ranges |= {
make_iprange(static_route.gateway_ip, purpose="gateway-ip")
}
ranges |= self._get_ranges_for_allocated_ips(
network, ignore_discovered_ips)
ranges |= set(
make_iprange(address, purpose="excluded")
for address in exclude_addresses if address in network)
if include_reserved:
ranges |= self.get_reserved_maasipset(
exclude_ip_ranges=exclude_ip_ranges)
ranges |= self.get_dynamic_maasipset(
exclude_ip_ranges=exclude_ip_ranges)
if with_neighbours:
ranges |= self.get_maasipset_for_neighbours()
return MAASIPSet(ranges)
def get_dynamic_maasipset(self):
dynamic_ranges = MAASIPSet(iprange.get_MAASIPRange()
for iprange in self.get_dynamic_ranges())
return dynamic_ranges
def get_reserved_maasipset(self):
reserved_ranges = MAASIPSet(iprange.get_MAASIPRange()
for iprange in self.get_reserved_ranges())
return reserved_ranges