dnmapper/bgpdata/models.py

224 lines
7.3 KiB
Python
Raw Normal View History

2018-01-19 13:28:52 +01:00
# This file is part of dnmapper, an AS--level mapping tool
# Licensed under GNU General Public License v3 or later
# Written by Sebastian Lohff (seba@someserver.de)
2015-03-23 01:42:31 +01:00
from django.db import models
from django.db.models import Q
# Create your models here.
class ConfigHost(models.Model):
CHECK_CHOICES = (
('CMK', "Check MK"),
('PLAIN', "Plain"),
2020-05-31 22:10:26 +02:00
('GOBGP', "GoBGP"),
)
2015-03-23 01:42:31 +01:00
# asno, ip, check method,
name = models.CharField(max_length=50)
number = models.IntegerField()
ip = models.GenericIPAddressField()
2020-05-31 22:10:26 +02:00
checkMethod = models.CharField(max_length=10, choices=CHECK_CHOICES)
2015-03-23 01:42:31 +01:00
def __str__(self):
return "%s (%s / %s)" % (self.name, self.number, self.ip)
2015-03-23 01:42:31 +01:00
2015-03-23 01:42:31 +01:00
class CrawlRun(models.Model):
# time start, time end,
startTime = models.DateTimeField()
endTime = models.DateTimeField(null=True, blank=True)
2020-06-06 22:01:51 +02:00
hostsCrawled = models.ManyToManyField(ConfigHost, blank=True)
graph = models.TextField()
asCount = models.IntegerField(default=0)
asOnlineCount = models.IntegerField(default=0)
asOfflineCount = models.IntegerField(default=0)
peeringCount = models.IntegerField(default=0)
def __str__(self):
return "Run %d - %s to %s" % (self.pk, self.startTime, self.endTime if self.endTime else "?")
def countAS(self):
return self.asCount
def countASOnline(self):
return self.asOnlineCount
def countASOffline(self):
return self.asOfflineCount
def countPeerings(self):
return self.peeringCount
2015-03-28 21:15:32 +01:00
2015-03-23 01:42:31 +01:00
class CrawlLog(models.Model):
INFO = 'INFO'
ERROR = 'ERROR'
DEBUG = 'DEBUG'
WARN = 'WARN'
SEVERITY = (
(INFO, 'info'),
(ERROR, 'error'),
(DEBUG, 'debug'),
(WARN, 'warning'),
)
2020-06-06 22:01:51 +02:00
crawl = models.ForeignKey(CrawlRun, on_delete=models.CASCADE)
host = models.ForeignKey(ConfigHost, null=True, blank=True, on_delete=models.SET_NULL)
logtime = models.DateTimeField(auto_now_add=True)
severity = models.CharField(max_length=10, choices=SEVERITY)
message = models.TextField()
@staticmethod
def log(crawl, msg, severity=None, host=None):
if not severity:
severity = CrawlLog.ERROR
log = CrawlLog()
log.crawl = crawl
log.message = msg
log.severity = severity
log.host = host
log.save()
def __str__(self):
host = "host %s - " % self.host.name if self.host else ""
return "Log %s %s: %s%s" % (self.get_severity_display(), self.logtime, host, self.message)
2015-03-23 01:42:31 +01:00
2015-03-23 01:42:31 +01:00
class AS(models.Model):
# asno
2020-06-06 22:01:51 +02:00
crawl = models.ForeignKey(CrawlRun, on_delete=models.CASCADE)
number = models.IntegerField(db_index=True)
2015-03-23 01:42:31 +01:00
directlyCrawled = models.BooleanField(default=False)
online = models.BooleanField(default=True, db_index=True)
2020-06-06 22:01:51 +02:00
lastSeen = models.ForeignKey(CrawlRun, blank=True, null=True, default=None, related_name='as_lastseen',
on_delete=models.CASCADE)
2015-03-27 15:33:54 +01:00
class Meta:
unique_together = (('crawl', 'number'),)
index_together = (
('crawl', 'number'),
)
2015-03-27 16:43:47 +01:00
def __str__(self):
return "AS %s (crawl %d)" % (self.number, self.crawl.pk)
2015-03-23 01:42:31 +01:00
def setOnline(self):
if not self.online:
self.online = True
self.lastSeen = None
self.save()
2015-03-27 16:43:47 +01:00
def getPeerings(self):
return Peering.objects.filter(Q(as1=self) | Q(as2=self))
2015-03-23 01:42:31 +01:00
def getAnnouncedPrefixes(self):
return list(set(map(lambda _x: "%(ip)s/%(prefix)s" % _x, self.announcement_set.all().values('ip', 'prefix'))))
def formatLastSeen(self):
if self.lastSeen:
return self.lastSeen.startTime.strftime("%d.%m.%Y %H:%I")
2015-03-28 19:47:52 +01:00
2015-03-23 01:42:31 +01:00
class BorderRouter(models.Model):
# as id, ip, check method, pingable, reachable
# unique: (crawl_id, asno, as id)
2020-06-06 22:01:51 +02:00
AS = models.ForeignKey(AS, on_delete=models.CASCADE)
routerID = models.GenericIPAddressField()
pingable = models.BooleanField(default=False)
reachable = models.BooleanField(default=False)
def __str__(self):
p = "p" if self.pingable else "!p"
r = "r" if self.reachable else "!r"
return "Router %s (AS %s, %s%s)" % (self.routerID, self.AS.number, p, r)
2015-03-23 01:42:31 +01:00
2015-03-23 01:42:31 +01:00
class Announcement(models.Model):
2020-06-06 22:01:51 +02:00
router = models.ForeignKey(BorderRouter, on_delete=models.CASCADE)
2015-03-23 01:42:31 +01:00
ip = models.GenericIPAddressField()
prefix = models.IntegerField()
2015-03-23 01:42:31 +01:00
# NOTE: increase length for longer pathes (currently supports a length of ~85)
ASPath = models.CharField(max_length=512)
nextHop = models.GenericIPAddressField()
2020-06-06 22:01:51 +02:00
originAS = models.ForeignKey(AS, null=True, on_delete=models.CASCADE)
crawlAS = models.ForeignKey(AS, related_name='crawl_as', null=True, on_delete=models.CASCADE)
2015-03-23 01:42:31 +01:00
def __str__(self):
return "%s/%s via %s (crawl %s)" % (self.ip, self.prefix, self.ASPath, self.router.AS.crawl.pk)
2015-03-23 01:42:31 +01:00
2015-03-23 01:42:31 +01:00
class Peering(models.Model):
DIRECT = 'direct'
PATH = 'path'
2015-03-23 01:42:31 +01:00
ORIGIN = (
(PATH, 'BGP Path'),
(DIRECT, 'Direct Connection'),
)
2015-03-23 01:42:31 +01:00
index_together = (
('as1', 'as2'),
)
2015-08-13 12:30:35 +02:00
2020-06-06 22:01:51 +02:00
as1 = models.ForeignKey(AS, related_name='peering1', on_delete=models.CASCADE)
as2 = models.ForeignKey(AS, related_name='peering2', on_delete=models.CASCADE)
origin = models.CharField(max_length=10, choices=ORIGIN)
2015-03-23 01:42:31 +01:00
def __str__(self):
return "AS %s <--> AS %s (%s, crawl %s)" % (self.as1.number, self.as2.number,
self.get_origin_display(), self.as1.crawl.pk)
2015-03-23 01:42:31 +01:00
def containsAS(self, AS):
return AS in (self.as1, self.as2)
2015-03-23 01:42:31 +01:00
@staticmethod
def getPeering(as1, as2):
""" Find matching peering """
try:
return Peering.objects.get(as1=as1, as2=as2)
except Peering.DoesNotExist:
return Peering.objects.get(as1=as2, as2=as1)
2015-03-23 01:42:31 +01:00
2015-03-23 01:42:31 +01:00
class BorderRouterPair(models.Model):
2020-06-06 22:01:51 +02:00
peering = models.ForeignKey(Peering, on_delete=models.CASCADE)
router1 = models.ForeignKey(BorderRouter, default=None, blank=True, null=True, related_name='routerpair1',
on_delete=models.CASCADE)
router2 = models.ForeignKey(BorderRouter, default=None, blank=True, null=True, related_name='routerpair2',
on_delete=models.CASCADE)
def __str__(self):
return "%s <--> %s (crawl %d)" % (self.router1, self.router2, self.router1.AS.crawl.pk)
@staticmethod
def getPairing(peering, router1, router2):
try:
return BorderRouterPair.objects.get(peering=peering, router1=router1, router2=router2)
except BorderRouterPair.DoesNotExist:
return BorderRouterPair.objects.get(peering=peering, router1=router2, router2=router1)
class ASLastSeen(models.Model):
asn = models.IntegerField(db_index=True, unique=True)
directlyCrawled = models.BooleanField(default=False)
online = models.BooleanField()
lastSeen = models.DateTimeField(blank=True, null=True)
2020-06-06 22:01:51 +02:00
crawlLastSeen = models.ForeignKey(CrawlRun, null=True, on_delete=models.SET_NULL)
def __str__(self):
return ("AS{} {}, last seen {} (crawl {})"
.format(self.asn, "online" if self.online else "offline", self.lastSeen, self.crawlLastSeen.pk))
class ASLastSeenNeighbor(models.Model):
asn = models.IntegerField()
2020-06-06 22:01:51 +02:00
neighbor = models.ForeignKey(ASLastSeen, on_delete=models.CASCADE)