""" This module contains models related to domain names. """ from __future__ import absolute_import, unicode_literals from django.db import models, transaction from django.conf import settings from django.utils.encoding import python_2_unicode_compatible from django.utils.translation import ugettext as _ from model_utils.models import TimeStampedModel from model_utils import Choices DNS_DOMAIN_TYPES = Choices( ('MASTER', _('Master')), ('SLAVE', _('Slave')), ('NATIVE', _('Native')), ) # see https://doc.powerdns.com/md/authoritative/domainmetadata/ DNS_DOMAIN_METADATA_KINDS = Choices( 'ALLOW-DNSUPDATE-FROM', 'ALSO-NOTIFY', 'AXFR-MASTER-TSIG', 'AXFR-SOURCE', 'FORWARD-DNSUPDATE', 'GSS-ACCEPTOR-PRINCIPAL', 'GSS-ALLOW-AXFR-PRINCIPAL', 'LUA-AXFR-SCRIPT', 'NSEC3NARROW', 'NSEC3PARAM', 'PRESIGNED', 'PUBLISH_CDNSKEY', 'PUBLISH_CDS', 'SOA-EDIT', 'SOA-EDIT-DNSUPDATE', 'TSIG-ALLOW-AXFR', 'TSIG-ALLOW-DNSUPDATE', ) DNS_TSIG_KEY_ALGORITHMS = Choices( ('hmac-md5', _('HMAC MD5')), ('hmac-sha1', _('HMAC SHA1')), ('hmac-sha224', _('HMAC SHA224')), ('hmac-sha256', _('HMAC SHA256')), ('hmac-sha384', _('HMAC SHA384')), ('hmac-sha512', _('HMAC SHA512')), ) @python_2_unicode_compatible class DomainBase(TimeStampedModel): """ This is the base model for domains. """ domain = models.CharField(_('domain name'), max_length=255, unique=True) customer = models.ForeignKey( settings.AUTH_USER_MODEL, verbose_name=_('customer'), blank=True, null=True) class Meta: abstract = True def __str__(self): return self.domain @python_2_unicode_compatible class MailDomain(DomainBase): """ This is the model for mail domains. Mail domains are used to configure the mail servers (SMTP/IMAP/POP3). Mail addresses are assigned to these mail domains. """ class Meta: verbose_name = _('Mail domain') verbose_name_plural = _('Mail domains') def __str__(self): return self.domain def get_mailaddresses(self): """ Get a list of mail addresses assigned to this mail domain. """ return self.mailaddress_set.all() mailaddresses = property(get_mailaddresses) class HostingDomainManager(models.Manager): """ Default Manager for :py:class:`HostingDomain`. """ @transaction.atomic def create_for_hosting_package( self, hosting_package, domain, commit, **kwargs ): from hostingpackages.models import CustomerHostingPackageDomain hostingdomain = self.create( customer=hosting_package.customer, domain=domain, **kwargs) hostingdomain.maildomain = MailDomain.objects.create( customer=hosting_package.customer, domain=domain) custdomain = CustomerHostingPackageDomain.objects.create( hosting_package=hosting_package, domain=hostingdomain) if commit: hostingdomain.save() custdomain.save() return hostingdomain @python_2_unicode_compatible class HostingDomain(DomainBase): """ This is the model for hosting domains. A hosting domain is linked to a customer hosting account. """ maildomain = models.OneToOneField( MailDomain, verbose_name=_('mail domain'), blank=True, null=True, help_text=_('assigned mail domain for this domain') ) objects = HostingDomainManager() class Meta: verbose_name = _('Hosting domain') verbose_name_plural = _('Hosting domains') def __str__(self): return self.domain @python_2_unicode_compatible class DNSDomain(DomainBase): """ This model represents a DNS zone. The model is similar to the domain table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. CREATE TABLE domains ( id SERIAL PRIMARY KEY, name VARCHAR(255) NOT NULL, master VARCHAR(128) DEFAULT NULL, last_check INT DEFAULT NULL, type VARCHAR(6) NOT NULL, notified_serial INT DEFAULT NULL, account VARCHAR(40) DEFAULT NULL, CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT))) ); CREATE UNIQUE INDEX name_index ON domains(name); """ # name is represented by domain master = models.CharField(max_length=128, blank=True, null=True) last_check = models.IntegerField(null=True) domaintype = models.CharField(max_length=6, choices=DNS_DOMAIN_TYPES, db_column='type') notified_serial = models.IntegerField(null=True) # account is represented by customer_id # check constraint is added via RunSQL in migration class Meta: verbose_name = _('DNS domain') verbose_name_plural = _('DNS domains') def __str__(self): return self.domain @python_2_unicode_compatible class DNSRecord(models.Model): """ This model represents a DNS record. The model is similar to the record table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. CREATE TABLE records ( id SERIAL PRIMARY KEY, domain_id INT DEFAULT NULL, name VARCHAR(255) DEFAULT NULL, type VARCHAR(10) DEFAULT NULL, content VARCHAR(65535) DEFAULT NULL, ttl INT DEFAULT NULL, prio INT DEFAULT NULL, change_date INT DEFAULT NULL, disabled BOOL DEFAULT 'f', ordername VARCHAR(255), auth BOOL DEFAULT 't', CONSTRAINT domain_exists FOREIGN KEY(domain_id) REFERENCES domains(id) ON DELETE CASCADE, CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT))) ); CREATE INDEX rec_name_index ON records(name); CREATE INDEX nametype_index ON records(name,type); CREATE INDEX domain_id ON records(domain_id); CREATE INDEX recordorder ON records (domain_id, ordername text_pattern_ops); """ domain = models.ForeignKey('DNSDomain') name = models.CharField(max_length=255, blank=True, null=True, db_index=True) recordtype = models.CharField(max_length=10, blank=True, null=True, db_column='type') content = models.CharField(max_length=65535, blank=True, null=True) ttl = models.IntegerField(null=True) prio = models.IntegerField(null=True) change_date = models.IntegerField(null=True) disabled = models.BooleanField(default=False) ordername = models.CharField(max_length=255) auth = models.BooleanField(default=True) # check constraint and index recordorder are added via RunSQL in migration class Meta: verbose_name = _('DNS record') verbose_name_plural = _('DNS records') index_together = [ ['name', 'recordtype'] ] def __str__(self): return "{name} IN {type} {content}".format( name=self.name, type=self.recordtype, content=self.content) @python_2_unicode_compatible class DNSSupermaster(models.Model): """ This model represents the supermasters table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. CREATE TABLE supermasters ( ip INET NOT NULL, nameserver VARCHAR(255) NOT NULL, account VARCHAR(40) NOT NULL, PRIMARY KEY(ip, nameserver) ); """ ip = models.GenericIPAddressField() nameserver = models.CharField(max_length=255) # account is replaced by customer customer = models.ForeignKey( settings.AUTH_USER_MODEL, verbose_name=_('customer')) class Meta: verbose_name = _('DNS supermaster') verbose_name_plural = _('DNS supermasters') unique_together = ( ('ip', 'nameserver') ) def __str__(self): return "{ip} {nameserver}".format( ip=self.ip, nameserver=self.nameserver) @python_2_unicode_compatible class DNSComment(models.Model): """ This model represents the comments table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. The comments table is used to store user comments related to individual DNS records. CREATE TABLE comments ( id SERIAL PRIMARY KEY, domain_id INT NOT NULL, name VARCHAR(255) NOT NULL, type VARCHAR(10) NOT NULL, modified_at INT NOT NULL, account VARCHAR(40) DEFAULT NULL, comment VARCHAR(65535) NOT NULL, CONSTRAINT domain_exists FOREIGN KEY(domain_id) REFERENCES domains(id) ON DELETE CASCADE, CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT))) ); CREATE INDEX comments_domain_id_idx ON comments (domain_id); CREATE INDEX comments_name_type_idx ON comments (name, type); CREATE INDEX comments_order_idx ON comments (domain_id, modified_at); """ domain = models.ForeignKey('DNSDomain') name = models.CharField(max_length=255) commenttype = models.CharField(max_length=10, db_column='type') modified_at = models.IntegerField() # account is replaced by customer customer = models.ForeignKey( settings.AUTH_USER_MODEL, verbose_name=_('customer')) comment = models.CharField(max_length=65535) # check constraint is added via RunSQL in migration class Meta: verbose_name = _('DNS comment') verbose_name_plural = _('DNS comments') index_together = [ ['name', 'commenttype'], ['domain', 'modified_at'] ] def __str__(self): return "{name} IN {type}: {comment}".format( name=self.name, type=self.commenttype, comment=self.comment) @python_2_unicode_compatible class DNSDomainMetadata(models.Model): """ This model represents the domainmetadata table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. The domainmetadata table is used to store domain meta data as described in https://doc.powerdns.com/md/authoritative/domainmetadata/. CREATE TABLE domainmetadata ( id SERIAL PRIMARY KEY, domain_id INT REFERENCES domains(id) ON DELETE CASCADE, kind VARCHAR(32), content TEXT ); CREATE INDEX domainidmetaindex ON domainmetadata(domain_id); """ domain = models.ForeignKey('DNSDomain') kind = models.CharField(max_length=32, choices=DNS_DOMAIN_METADATA_KINDS) content = models.TextField() class Meta: verbose_name = _('DNS domain metadata item') verbose_name_plural = _('DNS domain metadata items') def __str__(self): return "{domain} {kind} {content}".format( domain=self.domain.domain, kind=self.kind, content=self.content) @python_2_unicode_compatible class DNSCryptoKey(models.Model): """ This model represents the cryptokeys table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. CREATE TABLE cryptokeys ( id SERIAL PRIMARY KEY, domain_id INT REFERENCES domains(id) ON DELETE CASCADE, flags INT NOT NULL, active BOOL, content TEXT ); CREATE INDEX domainidindex ON cryptokeys(domain_id); """ domain = models.ForeignKey('DNSDomain') flags = models.IntegerField() active = models.BooleanField(default=True) content = models.TextField() class Meta: verbose_name = _('DNS crypto key') verbose_name_plural = _('DNS crypto keys') def __str__(self): return "{domain} {content}".format( domain=self.domain.domain, content=self.content) @python_2_unicode_compatible class DNSTSIGKey(models.Model): """ This model represents the tsigkeys table in the PowerDNS schema specified in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. CREATE TABLE tsigkeys ( id SERIAL PRIMARY KEY, name VARCHAR(255), algorithm VARCHAR(50), secret VARCHAR(255), CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT))) ); CREATE UNIQUE INDEX namealgoindex ON tsigkeys(name, algorithm); """ name = models.CharField(max_length=255) algorithm = models.CharField(max_length=50, choices=DNS_TSIG_KEY_ALGORITHMS) secret = models.CharField(max_length=255) # check constraint is added via RunSQL in migration class Meta: verbose_name = _('DNS TSIG key') verbose_name_plural = _('DNS TSIG keys') unique_together = [ ['name', 'algorithm'] ] def __str__(self): return "{name} {algorithm} XXXX".format( name=self.name, algorithm=self.algorithm)