def get_or_create(self, object, name, rd):
"""
:param object:
:param name:
:param rd:
:return:
"""
def set_cache(vrf):
self.cache_vrf_by_rd[vrf.rd] = vrf
self.cache_vrf_by_name[vrf.name] = vrf
return vrf
if name == "default":
if object.vrf:
# Use object's VRF is set
return object.vrf
# Get default VRF
try:
return self.cache_vrf_by_name["default"]
except KeyError:
return set_cache(VRF.get_global())
# Non-default VRF
if not rd:
rd = VRF.generate_rd(name)
# Lookup RD cache
try:
return self.cache_vrf_by_rd[rd]
except KeyError:
pass
# Lookup database
try:
return set_cache(VRF.objects.get(rd=rd))
except VRF.DoesNotExist:
pass
# VRF Not found, create
# Generate unique VRF in case of names clash
vrf_name = name
if VRF.objects.filter(name=vrf_name).exists():
# Name clash, generate new name by appending RD
vrf_name += "_%s" % rd
self.info(
object,
"Conflicting names for VRF %s. Using fallback name %s" %
(name, vrf_name))
# Create VRF
vrf = VRF(name=vrf_name, rd=rd, vrf_group=VRF.get_global().vrf_group)
vrf.save()
return set_cache(vrf)
def sync_ipam(self):
"""
Synchronize FQDN and address with IPAM
"""
from noc.ip.models.address import Address
from noc.ip.models.vrf import VRF
# Generate FQDN from template
fqdn = self.object_profile.get_fqdn(self)
# Get existing IPAM record
vrf = self.vrf if self.vrf else VRF.get_global()
try:
a = Address.objects.get(vrf=vrf, address=self.address)
except Address.DoesNotExist:
# Create new address
Address(
vrf=vrf,
address=self.address,
fqdn=fqdn,
managed_object=self
).save()
return
# Update existing address
if (a.managed_object != self or
a.address != self.address or a.fqdn != fqdn):
a.managed_object = self
a.address = self.address
a.fqdn = fqdn
a.save()
def unregister_dynamic_usage(self,
vrf=None,
name="default",
technology="IPoE"):
"""
Decrease dynamic pool usage
"""
## Avoid circular references
from noc.ip.models.vrf import VRF
from noc.ip.models.dynamicippoolusage import DynamicIPPoolUsage
self._check_technology(technology)
if not vrf:
vrf = VRF.get_global()
DynamicIPPoolUsage.unregister_usage(self, vrf, name, technology)
def get_data(self, **kwargs):
vrf_id = VRF.get_global().id
return self.from_query(title=self.title,
columns=[_("Prefix")],
query="""
SELECT prefix
FROM ip_prefix p
WHERE
vrf_id=%s
AND afi='4'
AND masklen(prefix)=30
AND NOT EXISTS (SELECT * FROM ip_address WHERE vrf_id=%s AND afi='4' AND prefix=p.prefix)
ORDER BY prefix
""",
params=[vrf_id, vrf_id],
enumerate=True)
def get_usage(cls,
termination_group,
vrf=None,
pool_name="default",
technology="IPoE"):
if not vrf:
vrf = VRF.get_global()
r = cls._get_collection().find_one(
{
"termination_group": termination_group.id,
"vrf": vrf.id,
"pool_name": pool_name,
"technology": technology
}, {"usage": 1})
if r:
return r["usage"]
else:
return 0
def get_data(self, request, **kwargs):
vrf_id = VRF.get_global().id
return self.from_query(title=self.title,
columns=["FQDN", "AFI", "N", "Addresses"],
query="""
SELECT fqdn, afi, COUNT(*),
array_to_string(ARRAY(SELECT address
FROM ip_address
WHERE fqdn=a.fqdn
AND vrf_id=%s
AND afi=a.afi
ORDER BY address),', ')
FROM ip_address a
WHERE vrf_id=%s
GROUP BY 1, 2
HAVING COUNT(*)>1
ORDER BY 3 DESC""",
params=[vrf_id, vrf_id])
def unregister_usage(cls,
termination_group,
vrf=None,
pool_name="default",
technology="IPoE"):
"""
Decrease usage counter
"""
if not vrf:
vrf = VRF.get_global()
cls._get_collection().update(
{
"termination_group": termination_group.id,
"vrf": vrf.id,
"pool_name": pool_name,
"technology": technology
}, {"$inc": {
"usage": -1
}},
upsert=True)
def get_data(self, **kwargs):
def reverse_format(p):
n, m = p.split("/")
n = n.split(".")[:-1]
n.reverse()
return "%s.%s.%s.in-addr.arpa" % (n[0], n[1], n[2])
vrf_id = VRF.get_global().id
return self.from_query(
title=self.title,
columns=["Prefix",
TableColumn("Zone", format=reverse_format)],
query="""
SELECT prefix,prefix
FROM ip_prefix
WHERE vrf_id=%s
AND masklen(prefix)=24
AND regexp_replace(host(prefix),E'([0-9]+)\\\\.([0-9]+)\\\\.([0-9]+)\\\\.([0-9]+)',E'\\\\3.\\\\2.\\\\1.in-addr.arpa')
NOT IN (SELECT name FROM dns_dnszone WHERE name LIKE '%%.in-addr.arpa')
ORDER BY 1
""",
params=[vrf_id],
enumerate=True)
def import_zone(self,
path,
zone_profile,
address_profile,
dry_run=False,
force=False,
clean=False):
self.print("Loading zone file '%s'" % path)
self.print("Parsing zone file using BIND parser")
with open(path) as f:
rrs = self.iter_bind_zone_rr(f)
try:
soa = next(rrs)
except StopIteration:
raise CommandError("Unable to parse zone file from %s" % path)
zone = self.from_idna(soa.zone)
z = DNSZone.get_by_name(zone)
if z:
self.print("Using existing zone '%s'" % zone)
else:
self.print("Creating zone '%s'" % zone)
z = DNSZone(name=zone, profile=zone_profile)
clean = False # Nothing to clean
if z.profile.id != zone_profile.id:
self.print("Setting profile to '%s'" % zone_profile.name)
z.profile = zone_profile
# Apply changes
if dry_run:
z.clean() # Set type
else:
z.save()
# Clean zone when necessary
if clean:
self.print("Cleaning zone")
for rr in DNSZoneRecord.objects.filter(zone=z):
self.print("Removing %s %s" % (rr.type, rr.name))
if not dry_run:
rr.delete()
# Populate zone
vrf = VRF.get_global()
zz = zone + "."
lz = len(zz)
if z.is_forward:
zp = None
elif z.is_reverse_ipv4:
# Calculate prefix for reverse zone
zp = ".".join(reversed(zone[:-13].split("."))) + "."
elif z.is_reverse_ipv6:
raise CommandError("IPv6 reverse import is not implemented")
else:
raise CommandError("Unknown zone type")
for rr in rrs:
name = rr.name
if name.endswith(zz):
name = name[:-lz]
if name.endswith("."):
name = name[:-1]
# rr = None
# Skip zone NS
if rr.type == "NS" and not name:
continue
if rr.type in ("A", "AAAA"):
self.create_address(
zone,
vrf,
rr.rdata,
"%s.%s" % (name, zone) if name else zone,
address_profile,
dry_run=dry_run,
force=force,
)
elif rr.type == "PTR":
if "." in name:
address = zp + ".".join(reversed(name.split(".")))
else:
address = zp + name
self.create_address(zone,
vrf,
address,
rr.rdata,
address_profile,
dry_run=dry_run,
force=force)
else:
zrr = DNSZoneRecord(
zone=z,
name=name,
type=rr.type,
ttl=rr.ttl,
priority=rr.priority,
content=rr.rdata,
)
self.print("Creating %s %s" % (rr.type, rr.name))
if not dry_run:
zrr.save()
def import_zone(
self,
path=None,
axfr=False,
zone_profile=None,
address_profile=None,
transfer_zone=None,
nameserver=None,
source_address=None,
dry_run=False,
force=False,
clean=False,
):
self.print("Loading zone file '%s'" % path)
self.print("Parsing zone file using BIND parser")
if path:
with open(path) as f:
rrs = self.iter_bind_zone_rr(f)
try:
soa = next(rrs)
except StopIteration:
raise CommandError("Unable to parse zone file from %s" %
path)
zone = self.from_idna(soa.zone)
z = self.dns_zone(zone, zone_profile, dry_run, clean)
# Populate zone
vrf = VRF.get_global()
zz = zone + "."
lz = len(zz)
if z.is_forward:
zp = None
elif z.is_reverse_ipv4:
# Calculate prefix for reverse zone
zp = ".".join(reversed(zone[:-13].split("."))) + "."
elif z.is_reverse_ipv6:
raise CommandError(
"IPv6 reverse import is not implemented")
else:
raise CommandError("Unknown zone type")
for rr in rrs:
name = rr.name
if name.endswith(zz):
name = name[:-lz]
if name.endswith("."):
name = name[:-1]
# rr = None
# Skip zone NS
if rr.type == "NS" and not name:
continue
if rr.type in ("A", "AAAA"):
self.create_address(
zone,
vrf,
rr.rdata,
"%s.%s" % (name, zone) if name else zone,
address_profile,
dry_run=dry_run,
force=force,
)
elif rr.type == "PTR":
if "." in name:
address = zp + ".".join(reversed(name.split(".")))
else:
address = zp + name
self.create_address(
zone,
vrf,
address,
rr.rdata,
address_profile,
dry_run=dry_run,
force=force,
)
else:
zrr = DNSZoneRecord(
zone=z,
name=name,
type=rr.type,
ttl=rr.ttl,
priority=rr.priority,
content=rr.rdata,
)
self.print("Creating %s %s" % (rr.type, rr.name))
if not dry_run:
zrr.save()
if axfr:
data = self.load_axfr(nameserver, transfer_zone, source_address)
zone = self.from_idna(transfer_zone)
z = self.dns_zone(zone, zone_profile, dry_run, clean)
# Populate zone
vrf = VRF.get_global()
zz = zone + "."
lz = len(zz)
if z.is_forward:
zp = None
elif z.is_reverse_ipv4:
# Calculate prefix for reverse zone
zp = ".".join(reversed(zone[:-13].split("."))) + "."
elif z.is_reverse_ipv6:
raise CommandError("IPv6 reverse import is not implemented")
else:
raise CommandError("Unknown zone type")
for row in data:
row = row.strip()
if row == "" or row.startswith(";"):
continue
row = row.split()
if len(row) != 5 or row[2] != "IN" or row[3] not in ("A",
"AAAA",
"PTR"):
continue
if row[3] in ("A", "AAAA"):
name = row[0]
if name.endswith(zz):
name = name[:-lz]
if name.endswith("."):
name = name[:-1]
self.create_address(
zone,
vrf,
row[4],
"%s.%s" % (name, zone) if name else zone,
address_profile,
dry_run=dry_run,
force=force,
)
if row[3] == "PTR":
name = row[4]
if name.endswith(zz):
name = name[:-lz]
if name.endswith("."):
name = name[:-1]
# @todo: IPv6
if "." in row[0]:
address = ".".join(reversed(row[0].split(".")[:-3]))
else:
address = zp + name
fqdn = row[4]
if fqdn.endswith("."):
fqdn = fqdn[:-1]
self.create_address(zone,
vrf,
address,
fqdn,
address_profile,
dry_run=dry_run,
force=force)
def import_zone(self, path, options):
is_test = bool(options["test"])
self.info("Loading zone file '%s'" % path)
with open(path) as f:
data = f.read()
self.info("Parsing zone file using BIND parser")
zone, rrs = self.parse_bind_zone(data)
if not zone or not rrs:
raise CommandError("Unable to parse zone file")
# Find profile
profile = self.get_profile(options)
# Get or create zone
to_clean = bool(options["clean"])
try:
z = DNSZone.objects.get(name=zone)
self.info("Using existing zone '%s'" % z)
except DNSZone.DoesNotExist:
self.info("Creating zone '%s'" % zone)
z = DNSZone(name=zone, profile=profile)
to_clean = False # Nothing to clean yet
if z.profile != profile:
self.info("Setting profile to '%s'" % profile)
z.profile = profile
if not is_test:
z.save()
# Clean zone when necessary
if to_clean and z.id:
self.info("Cleaning zone")
for rr in z.dnszonerecord_set.all():
self.info("Removing %s %s" % (rr.type, rr.name))
if not is_test:
rr.delete()
# Populate zone
vrf = VRF.get_global()
zz = zone + "."
lz = len(zz)
if zone.endswith(".in-addr.arpa"):
# Calculate prefix for reverse zone
zp = zone[:-13].split(".")
zp.reverse()
zp = ".".join(zp) + "."
else:
# @todo: IPv6 reverse
zp = None
for name, t, value, ttl, priority in rrs:
# print name, t, value
if name.endswith(zz):
name = name[:-lz]
if name.endswith("."):
name = name[:-1]
rr = None
if (t == "SOA") or (t == "NS" and not name):
continue
if t in ("A", "AAAA"):
afi = "4" if t == "A" else "6"
self.create_address(
zone, vrf, afi, value,
"%s.%s" % (name, zone) if name else zone, is_test)
elif t == "PTR":
if not zp:
raise CommandError("IPv6 reverse zone import is still not supported")
address = zp + name
afi = "6" if ":" in address else "4"
self.create_address(zone, vrf, afi, address, value, is_test)
else:
rr = DNSZoneRecord(
zone=z, name=name, type=t,
ttl=ttl, priority=priority,
content=value
)
if rr:
self.info("Creating %s %s" % (rr.type, rr.name))
if not is_test:
rr.save()