372 lines
16 KiB
Python
372 lines
16 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (C) 2007, 2008 by Jan Dittberner.
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
|
|
# USA.
|
|
#
|
|
# Version: $Id$
|
|
"""This module defines the code for handling domains."""
|
|
|
|
import datetime
|
|
import os
|
|
|
|
from gnuviechadmin.exceptions import ValidationFailedError
|
|
from gnuviechadmin.backend.settings import config, get_template, \
|
|
get_template_dir, get_template_string
|
|
from gnuviechadmin.backend.BackendTo import Record, Domain
|
|
from gnuviechadmin.backend.BackendEntity import BackendEntity
|
|
from gnuviechadmin.backend.BackendEntityHandler import BackendEntityHandler
|
|
|
|
|
|
class DomainEntity(BackendEntity):
|
|
"""Entity class for DNS domains."""
|
|
|
|
# the valid domain types
|
|
_valid_domain_types = ("MASTER", "SLAVE")
|
|
|
|
def __init__(self, delegate, verbose = False, **kwargs):
|
|
"""Initializes the DomainEntity instance.
|
|
|
|
`delegate` is the corresponding database object.
|
|
If `verbose` is `True` verbose logging is turned on.
|
|
"""
|
|
BackendEntity.__init__(self, delegate, verbose)
|
|
self.ns1 = None
|
|
self.ns2 = None
|
|
self.mxrr = None
|
|
self.ipaddr = None
|
|
for (key, value) in kwargs.items():
|
|
self.__setattr__(key, value)
|
|
if not self.delegateto.type:
|
|
self.delegateto.type = self.getdefaultdomaintype()
|
|
if not self.ns1:
|
|
self.ns1 = config.get('domain', 'defaultns1')
|
|
if not self.ns2:
|
|
self.ns2 = config.get('domain', 'defaultns2')
|
|
if not self.mxrr:
|
|
self.mxrr = config.get('domain', 'defaultmx')
|
|
if not self.ipaddr:
|
|
self.ipaddr = config.get('domain', 'defaultip')
|
|
self.delegateto.type = self.delegateto.type.upper()
|
|
self.validate()
|
|
|
|
def getdefaultdomaintype(self):
|
|
"""Returns the default domain type."""
|
|
return self._valid_domain_types[0]
|
|
|
|
def validate(self):
|
|
"""Validates the consistency if the entity instance and
|
|
dependent entities."""
|
|
BackendEntity.validate(self)
|
|
if not self.delegateto.type in self._valid_domain_types:
|
|
raise ValidationFailedError(
|
|
self, "invalid domain type %s" % (self.delegateto.type))
|
|
if self.delegateto.type == 'SLAVE' and not self.delegateto.master:
|
|
raise ValidationFailedError(
|
|
self, "you have to specify a master for slave domains.")
|
|
if self.delegateto.type == 'MASTER':
|
|
if not self.ns1 or not self.ns2:
|
|
raise ValidationFailedError(
|
|
self, "two nameservers must be specified.")
|
|
if not self.mxrr:
|
|
raise ValidationFailedError(
|
|
self, "a primary mx host must be specified.")
|
|
|
|
def _getnewserial(self, oldserial = None):
|
|
"""Gets a new zone serial number for the DNS domain entity."""
|
|
current = datetime.datetime.now()
|
|
datepart = "%04d%02d%02d" % \
|
|
(current.year, current.month, current.day)
|
|
retval = None
|
|
if oldserial:
|
|
if str(oldserial)[:len(datepart)] == datepart:
|
|
retval = oldserial + 1
|
|
if not retval:
|
|
retval = int("%s01" % (datepart))
|
|
return retval
|
|
|
|
def _getnewsoa(self):
|
|
"""Gets a new SOA record for the DNS domain entity."""
|
|
return '%s %s %d %d %d %d %d' % \
|
|
(self.ns1,
|
|
config.get('domain', 'defaulthostmaster'),
|
|
self._getnewserial(),
|
|
config.getint('domain', 'defaultrefresh'),
|
|
config.getint('domain', 'defaultretry'),
|
|
config.getint('domain', 'defaultexpire'),
|
|
config.getint('domain', 'defaultminimumttl'))
|
|
|
|
def update_serial(self, session):
|
|
"""Updates the serial of the domain."""
|
|
query = session.query(Record)
|
|
soarecord = query.get_by(Record.c.type == 'SOA',
|
|
Record.c.domainid == self.delegateto.domainid)
|
|
parts = soarecord.content.split(" ")
|
|
parts[2] = str(self._getnewserial(int(parts[2])))
|
|
soarecord.content = " ".join(parts)
|
|
session.save(soarecord)
|
|
session.flush()
|
|
|
|
def _get_vhost_dir(self):
|
|
"""Gets the directory name for the Apache VirtualHost of the
|
|
domain."""
|
|
return os.path.join(self.delegateto.sysuser.home,
|
|
self.delegateto.name,
|
|
config.get('domain', 'htdir'))
|
|
|
|
def _get_log_dir(self):
|
|
"""Gets the Apache log file directory for the domain."""
|
|
return os.path.join(config.get('domain', 'logpath'),
|
|
self.delegateto.name)
|
|
|
|
def _get_stats_dir(self):
|
|
"""Gets the statistics dir for the domain."""
|
|
return os.path.join(config.get('domain', 'statspath'),
|
|
self.delegateto.name)
|
|
|
|
def _create_vhost_dir(self):
|
|
"""Creates the Apache VirtualHost directory for the domain."""
|
|
vhostdir = self._get_vhost_dir()
|
|
self.logger.debug("creating virtual host dir %s" % (vhostdir))
|
|
cmd = 'mkdir -p "%s"' % (vhostdir)
|
|
self.sucommand(cmd)
|
|
for tpl in [tpl for tpl in os.listdir(
|
|
get_template_dir(config.get('domain', 'htdocstemplate'))) \
|
|
if not tpl.startswith('.')]:
|
|
self.logger.debug("processing template %s" % (tpl))
|
|
template = get_template(config.get('domain', 'htdocstemplate'),
|
|
tpl)
|
|
template = template.substitute({
|
|
'domain': self.delegateto.name})
|
|
self.write_to_file(os.path.join(vhostdir, tpl), template)
|
|
cmd = 'chown -R %(username)s:%(group)s "%(dir)s"' % {
|
|
'username': self.delegateto.sysuser.username,
|
|
'group': config.get('sysuser', 'defaultgroup'),
|
|
'dir': vhostdir}
|
|
self.sucommand(cmd)
|
|
|
|
def _create_log_dir(self):
|
|
"""Creates the Apache log file directory for the domain."""
|
|
cmd = 'mkdir -p "%s"' % (self._get_log_dir())
|
|
self.sucommand(cmd)
|
|
|
|
def _get_auth_userfile(self):
|
|
"""Gets the file name of the password file for statistic
|
|
logins for the domain."""
|
|
authdir = config.get('domain', 'authdir')
|
|
if not os.path.isdir(authdir):
|
|
cmd = 'mkdir -p "%s"' % (authdir)
|
|
self.sucommand(cmd)
|
|
return os.path.join(authdir, '%s.passwd' % (self.delegateto.name))
|
|
|
|
def _create_stats_dir(self):
|
|
"""Creates the statistics directory for the domain and sets
|
|
Apache .htaccess password protection."""
|
|
statsdir = self._get_stats_dir()
|
|
authfile = self._get_auth_userfile()
|
|
cmd = 'htpasswd -m -c -b "%s" "%s" "%s"' % (
|
|
authfile,
|
|
self.delegateto.sysuser.username,
|
|
self.delegateto.sysuser.clearpass)
|
|
self.sucommand(cmd)
|
|
cmd = 'mkdir -p "%s"' % (statsdir)
|
|
self.sucommand(cmd)
|
|
template = get_template(config.get('domain', 'conftemplates'),
|
|
config.get('domain', 'statshtaccesstemplate'))
|
|
template = template.substitute({
|
|
'domain': self.delegateto.name,
|
|
'userfile': authfile})
|
|
self.write_to_file(os.path.join(self._get_stats_dir(),
|
|
'.htaccess'), template)
|
|
|
|
def _create_stats_conf(self):
|
|
"""Creates the modlogan statistics configuration for the
|
|
domain."""
|
|
modlogandir = os.path.join(config.get('domain',
|
|
'modlogandir'),
|
|
self.delegateto.sysuser.username)
|
|
cmd = 'mkdir -p "%s"' % (modlogandir)
|
|
self.sucommand(cmd)
|
|
template = get_template(config.get('domain', 'conftemplates'),
|
|
config.get('domain', 'modlogantemplate'))
|
|
template = template.substitute({
|
|
'statsdir': self._get_stats_dir(),
|
|
'logdir': self._get_log_dir(),
|
|
'domain': self.delegateto.name,
|
|
'domainesc': self.delegateto.name.replace('.', '\.')})
|
|
self.write_to_file(os.path.join(modlogandir,
|
|
self.delegateto.name + '.conf'),
|
|
template)
|
|
|
|
def _create_apache_conf(self):
|
|
"""Creates the Apache configuration file for the domain."""
|
|
template = get_template(config.get('domain', 'conftemplates'),
|
|
config.get('domain', 'apachetemplate'))
|
|
template = template.substitute({
|
|
'ipaddr': self.ipaddr,
|
|
'statsdir': self._get_stats_dir(),
|
|
'logdir': self._get_log_dir(),
|
|
'domain': self.delegateto.name,
|
|
'docroot': self._get_vhost_dir()})
|
|
self.write_to_file(os.path.join(config.get('domain', 'sitesdir'),
|
|
self.delegateto.name), template)
|
|
|
|
def _mail_domain(self):
|
|
"""Mail a summary of the domain data."""
|
|
template = get_template(config.get('common', 'mailtemplates'),
|
|
config.get('domain', 'create.mail'))
|
|
text = template.substitute({
|
|
'sysuser': self.delegateto.sysuser.username,
|
|
'domain': self.delegateto.name,
|
|
'docroot': self._get_vhost_dir(),
|
|
'statspass': self.delegateto.sysuser.clearpass})
|
|
template = get_template_string(config.get('domain', 'create_subject'))
|
|
subject = template.substitute({
|
|
'domain': self.delegateto.name})
|
|
self.send_mail(subject, text)
|
|
|
|
def create_hook(self, session):
|
|
"""Hook for the creation of the domain.
|
|
|
|
This method is called by
|
|
`gnuviechadmin.backend.BackendEntityHandler.create()`.
|
|
"""
|
|
self.delegateto.records.append(Record(
|
|
name = self.delegateto.name, type = 'SOA',
|
|
content = self._getnewsoa(),
|
|
ttl = config.getint('domain', 'defaultttl')))
|
|
self.delegateto.records.append(Record(
|
|
name = self.delegateto.name, type = 'NS', content = self.ns1,
|
|
ttl = config.getint('domain', 'defaultttl')))
|
|
self.delegateto.records.append(Record(
|
|
name = self.delegateto.name, type = 'NS', content = self.ns2,
|
|
ttl = config.getint('domain', 'defaultttl')))
|
|
self.delegateto.records.append(Record(
|
|
name = self.delegateto.name, type = 'MX', content = self.mxrr,
|
|
ttl = config.getint('domain', 'defaultttl'),
|
|
prio = config.getint('domain', 'defaultmxprio')))
|
|
self.delegateto.records.append(Record(
|
|
name = self.delegateto.name, type = 'A', content = self.ipaddr,
|
|
ttl = config.getint('domain', 'defaultttl')))
|
|
self.delegateto.records.append(Record(
|
|
name = "www.%s" % (self.delegateto.name), type = 'A',
|
|
content = self.ipaddr,
|
|
ttl = config.getint('domain', 'defaultttl')))
|
|
session.save_or_update(self.delegateto)
|
|
session.flush()
|
|
self._create_vhost_dir()
|
|
self._create_log_dir()
|
|
self._create_stats_dir()
|
|
self._create_stats_conf()
|
|
self._create_apache_conf()
|
|
self._mail_domain()
|
|
|
|
def _delete_apache_conf(self):
|
|
"""Deletes the Apache configuration file for the domain."""
|
|
cmd = 'a2dissite %s' % (self.delegateto.name)
|
|
self.sucommand(cmd)
|
|
cmd = 'rm "%s"' % (os.path.join(config.get('domain', 'sitesdir'),
|
|
self.delegateto.name))
|
|
self.sucommand(cmd)
|
|
|
|
def _delete_stats_conf(self):
|
|
"""Deletes the modlogan stastics configuration for the
|
|
domain."""
|
|
cmd = 'rm "%s"' % (os.path.join(config.get('domain', 'modlogandir'),
|
|
self.delegateto.sysuser.username,
|
|
self.delegateto.name + '.conf'))
|
|
self.sucommand(cmd)
|
|
|
|
def _archive_stats_dir(self):
|
|
"""Archives the statistics directory for the domain."""
|
|
archive = os.path.join(self.delegateto.sysuser.home,
|
|
'%(domain)s-stats.tar.gz' % {
|
|
'domain': self.delegateto.name})
|
|
cmd = 'tar czf "%(archive)s" --directory="%(statsbase)s" ' + \
|
|
'"%(statsdir)s"' % {
|
|
'archive': archive,
|
|
'statsbase': config.get('domain', 'statspath'),
|
|
'statsdir': self.delegateto.name}
|
|
self.sucommand(cmd)
|
|
cmd = 'rm -r "%(statsdir)s"' % {
|
|
'statsdir': self._get_stats_dir()}
|
|
self.sucommand(cmd)
|
|
cmd = 'chown "%(username)s:%(group)s" "%(archive)s"' % {
|
|
'username': self.delegateto.sysuser.username,
|
|
'group': config.get('sysuser', 'defaultgroup'),
|
|
'archive': archive}
|
|
self.sucommand(cmd)
|
|
|
|
def _archive_log_dir(self):
|
|
"""Archives the Apache log file directory for the domain."""
|
|
archive = os.path.join(self.delegateto.sysuser.home,
|
|
'%(domain)s-logs.tar.gz' % {
|
|
'domain': self.delegateto.name})
|
|
cmd = 'tar czf "%(archive)s" --directory="%(logbase)s" ' + \
|
|
'"%(logdir)s"' % {
|
|
'archive': archive,
|
|
'logbase': config.get('domain', 'logpath'),
|
|
'logdir': self.delegateto.name}
|
|
self.sucommand(cmd)
|
|
cmd = 'rm -r "%(logdir)s"' % {
|
|
'logdir': self._get_log_dir()}
|
|
self.sucommand(cmd)
|
|
cmd = 'chown "%(username)s:%(group)s" "%(archive)s"' % {
|
|
'username': self.delegateto.sysuser.username,
|
|
'group': config.get('sysuser', 'defaultgroup'),
|
|
'archive': archive}
|
|
self.sucommand(cmd)
|
|
|
|
def _archive_vhost_dir(self):
|
|
"""Archives the Apache VirtualHost directory for the domain."""
|
|
archive = os.path.join(self.delegateto.sysuser.home,
|
|
'%(domain)s-vhost.tar.gz' % {
|
|
'domain': self.delegateto.name})
|
|
cmd = 'tar czf "%(archive)s" --directory="%(vhostbase)s" ' + \
|
|
'"%(vhostdir)s"' % {
|
|
'archive': archive,
|
|
'vhostbase': self.delegateto.sysuser.home,
|
|
'vhostdir': self.delegateto.name}
|
|
self.sucommand(cmd)
|
|
cmd = 'rm -r "%(vhostdir)s"' % {
|
|
'vhostdir': os.path.join(self.delegateto.sysuser.home,
|
|
self.delegateto.name)}
|
|
self.sucommand(cmd)
|
|
cmd = 'chown "%(username)s:%(group)s" "%(archive)s"' % {
|
|
'username': self.delegateto.sysuser.username,
|
|
'group': config.get('sysuser', 'defaultgroup'),
|
|
'archive': archive}
|
|
self.sucommand(cmd)
|
|
|
|
def delete_hook(self, session):
|
|
"""Deletes domain related files and directories.
|
|
|
|
This method is called by `BackendEntityHandler.delete()`.
|
|
"""
|
|
self._delete_apache_conf()
|
|
self._delete_stats_conf()
|
|
self._archive_stats_dir()
|
|
self._archive_log_dir()
|
|
self._archive_vhost_dir()
|
|
|
|
|
|
class DomainHandler(BackendEntityHandler):
|
|
"""BackendEntityHandler for Domain entities."""
|
|
|
|
def __init__(self, verbose = False):
|
|
"""Initialize the DomainHandler."""
|
|
BackendEntityHandler.__init__(self, DomainEntity, Domain, verbose)
|