¡@

Home 

OpenStack Study: minidns.py

OpenStack Index

**** CubicPower OpenStack Study ****

# Copyright 2011 Andrew Bogott for the Wikimedia Foundation

#

# Licensed under the Apache License, Version 2.0 (the "License"); you may

# not use this file except in compliance with the License. You may obtain

# a copy of the License at

#

# http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

# License for the specific language governing permissions and limitations

# under the License.

import os

import shutil

import tempfile

from oslo.config import cfg

from nova import exception

from nova.network import dns_driver

from nova.openstack.common.gettextutils import _

from nova.openstack.common import log as logging

CONF = cfg.CONF

LOG = logging.getLogger(__name__)

**** CubicPower OpenStack Study ****

class MiniDNS(dns_driver.DNSDriver):

"""Trivial DNS driver. This will read/write to a local, flat file

and have no effect on your actual DNS system. This class is

strictly for testing purposes, and should keep you out of dependency

hell.

Note that there is almost certainly a race condition here that

will manifest anytime instances are rapidly created and deleted.

A proper implementation will need some manner of locking.

"""

**** CubicPower OpenStack Study ****

    def __init__(self):

        if CONF.log_dir:

            self.filename = os.path.join(CONF.log_dir, "dnstest.txt")

            self.tempdir = None

        else:

            self.tempdir = tempfile.mkdtemp()

            self.filename = os.path.join(self.tempdir, "dnstest.txt")

        LOG.debug(_('minidns file is |%s|'), self.filename)

        if not os.path.exists(self.filename):

            f = open(self.filename, "w+")

            f.write("#  minidns\n\n\n")

            f.close()

**** CubicPower OpenStack Study ****

    def get_domains(self):

        entries = []

        infile = open(self.filename, 'r')

        for line in infile:

            entry = self.parse_line(line)

            if entry and entry['address'] == 'domain':

                entries.append(entry['name'])

        infile.close()

        return entries

**** CubicPower OpenStack Study ****

    def qualify(self, name, domain):

        if domain:

            qualified = "%s.%s" % (name, domain)

        else:

            qualified = name

        return qualified.lower()

**** CubicPower OpenStack Study ****

    def create_entry(self, name, address, type, domain):

        if name is None:

            raise exception.InvalidInput(_("Invalid name"))

        if type.lower() != 'a':

            raise exception.InvalidInput(_("This driver only supports "

                                           "type 'a'"))

        if self.get_entries_by_name(name, domain):

            raise exception.FloatingIpDNSExists(name=name, domain=domain)

        outfile = open(self.filename, 'a+')

        outfile.write("%s   %s   %s\n" %

            (address, self.qualify(name, domain), type))

        outfile.close()

**** CubicPower OpenStack Study ****

    def parse_line(self, line):

        vals = line.split()

        if len(vals) < 3:

            return None

        else:

            entry = {}

            entry['address'] = vals[0].lower()

            entry['name'] = vals[1].lower()

            entry['type'] = vals[2].lower()

            if entry['address'] == 'domain':

                entry['domain'] = entry['name']

            else:

                entry['domain'] = entry['name'].partition('.')[2]

            return entry

**** CubicPower OpenStack Study ****

    def delete_entry(self, name, domain):

        if name is None:

            raise exception.InvalidInput(_("Invalid name"))

        deleted = False

        infile = open(self.filename, 'r')

        outfile = tempfile.NamedTemporaryFile('w', delete=False)

        for line in infile:

            entry = self.parse_line(line)

            if ((not entry) or

                    entry['name'] != self.qualify(name, domain)):

                outfile.write(line)

            else:

                deleted = True

        infile.close()

        outfile.close()

        shutil.move(outfile.name, self.filename)

        if not deleted:

            LOG.warn(_('Cannot delete entry |%s|'),

                self.qualify(name, domain))

            raise exception.NotFound

**** CubicPower OpenStack Study ****

    def modify_address(self, name, address, domain):

        if not self.get_entries_by_name(name, domain):

            raise exception.NotFound

        infile = open(self.filename, 'r')

        outfile = tempfile.NamedTemporaryFile('w', delete=False)

        for line in infile:

            entry = self.parse_line(line)

            if (entry and

                    entry['name'] == self.qualify(name, domain)):

                outfile.write("%s   %s   %s\n" %

                    (address, self.qualify(name, domain), entry['type']))

            else:

                outfile.write(line)

        infile.close()

        outfile.close()

        shutil.move(outfile.name, self.filename)

**** CubicPower OpenStack Study ****

    def get_entries_by_address(self, address, domain):

        entries = []

        infile = open(self.filename, 'r')

        for line in infile:

            entry = self.parse_line(line)

            if entry and entry['address'] == address.lower():

                if entry['name'].endswith(domain.lower()):

                    name = entry['name'].split(".")[0]

                    if name not in entries:

                        entries.append(name)

        infile.close()

        return entries

**** CubicPower OpenStack Study ****

    def get_entries_by_name(self, name, domain):

        entries = []

        infile = open(self.filename, 'r')

        for line in infile:

            entry = self.parse_line(line)

            if (entry and

                    entry['name'] == self.qualify(name, domain)):

                entries.append(entry['address'])

        infile.close()

        return entries

**** CubicPower OpenStack Study ****

    def delete_dns_file(self):

        if os.path.exists(self.filename):

            try:

                os.remove(self.filename)

            except OSError:

                pass

        if self.tempdir and os.path.exists(self.tempdir):

            try:

                shutil.rmtree(self.tempdir)

            except OSError:

                pass

**** CubicPower OpenStack Study ****

    def create_domain(self, fqdomain):

        if self.get_entries_by_name(fqdomain, ''):

            raise exception.FloatingIpDNSExists(name=fqdomain, domain='')

        outfile = open(self.filename, 'a+')

        outfile.write("%s   %s   %s\n" %

            ('domain', fqdomain, 'domain'))

        outfile.close()

**** CubicPower OpenStack Study ****

    def delete_domain(self, fqdomain):

        deleted = False

        infile = open(self.filename, 'r')

        outfile = tempfile.NamedTemporaryFile('w', delete=False)

        for line in infile:

            entry = self.parse_line(line)

            if ((not entry) or

                    entry['domain'] != fqdomain.lower()):

                outfile.write(line)

            else:

                LOG.info(_("deleted %s"), entry)

                deleted = True

        infile.close()

        outfile.close()

        shutil.move(outfile.name, self.filename)

        if not deleted:

            LOG.warn(_('Cannot delete domain |%s|'), fqdomain)

            raise exception.NotFound