# Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.

#

#    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.

#

# @author: Girish Moodalbail, Oracle, Inc.

import abc

import os

import re

import shutil

import StringIO

import netaddr

LOG = logging.getLogger(__name__)

OPTS = [

    cfg.StrOpt('dhcp_confs',

               default='$state_path/dhcp',

               help=_('Location to store DHCP server config files')),

    cfg.StrOpt('dhcp_domain',

               default='openstacklocal',

               help=_('Domain to use for building the hostnames')),

    cfg.StrOpt('dnsmasq_config_file',

               default='',

               help=_('Override the default dnsmasq settings with this file')),

    cfg.StrOpt('dnsmasq_dns_server',

               help=_('Use another DNS server before any in '

                      '/etc/resolv.conf.')),

]

IPV4 = 4

IPV6 = 6

UDP = 'udp'

TCP = 'tcp'

DNS_PORT = 53

DHCPV4_PORT = 67

class DhcpBase(object):

    __metaclass__ = abc.ABCMeta

    def __init__(self, conf, network, root_helper='sudo',

        self.conf = conf

        self.network = network

        self.version = version

    @abc.abstractmethod

    def enable(self):

        """Enables DHCP for this network."""

    @abc.abstractmethod

    def disable(self, retain_port=False):

        """Disable dhcp for this network."""

    def restart(self):

        """Restart the dhcp service for the network."""

        self.disable(retain_port=True)

        self.enable()

    @abc.abstractproperty

    def active(self):

        """Boolean representing the running state of the DHCP server."""

    @abc.abstractmethod

    def reload_allocations(self):

        """Force the DHCP server to reload the assignment database."""

    @classmethod

    def existing_dhcp_networks(cls, conf, root_helper):

        raise NotImplementedError

    @classmethod

    def check_version(cls):

        """Execute version checks on DHCP server."""

        raise NotImplementedError

class DhcpLocalProcess(DhcpBase):

    PORTS = []

    def _enable_dhcp(self):

        """check if there is a subnet within the network with dhcp enabled."""

    def enable(self):

        """Enables DHCP for this network by spawning a local process."""

        if self.active:

            self.restart()

        elif self._enable_dhcp():

            self.interface_name = interface_name

            self.spawn_process()

    def disable(self, retain_port=False):

        """Disable DHCP for this network by killing the local process."""

        pid = self.pid

        if self.active:

            cmd = ['kill', '-9', pid]

            if not retain_port:

        elif pid:

            LOG.debug(_('DHCP for %(net_id)s pid %(pid)d is stale, ignoring '

                        'command'), {'net_id': self.network.id, 'pid': pid})

        else:

            LOG.debug(_('No DHCP started for %s'), self.network.id)

        self._remove_config_files()

    def _remove_config_files(self):

        confs_dir = os.path.abspath(os.path.normpath(self.conf.dhcp_confs))

        conf_dir = os.path.join(confs_dir, self.network.id)

        shutil.rmtree(conf_dir, ignore_errors=True)

    def get_conf_file_name(self, kind, ensure_conf_dir=False):

        """Returns the file name for a given kind of config file."""

        confs_dir = os.path.abspath(os.path.normpath(self.conf.dhcp_confs))

        conf_dir = os.path.join(confs_dir, self.network.id)

        if ensure_conf_dir:

            if not os.path.isdir(conf_dir):

        return os.path.join(conf_dir, kind)

    def _get_value_from_conf_file(self, kind, converter=None):

        """A helper function to read a value from one of the state files."""

        file_name = self.get_conf_file_name(kind)

        msg = _('Error while reading %s')

        try:

            with open(file_name, 'r') as f:

                try:

                    return converter and converter(f.read()) or f.read()

                    msg = _('Unable to convert value in %s')

            msg = _('Unable to access %s')

        LOG.debug(msg % file_name)

        return None

    @property

    def pid(self):

        """Last known pid for the DHCP process spawned for this network."""

        return self._get_value_from_conf_file('pid', int)

    @property

    def active(self):

        pid = self.pid

        if pid is None:

            return False

        try:

            return self.network.id in utils.execute(cmd)

        except RuntimeError:

            return False

    @property

    def interface_name(self):

        return self._get_value_from_conf_file('interface')

    @interface_name.setter

    def interface_name(self, value):

        interface_file_path = self.get_conf_file_name('interface',

                                                      ensure_conf_dir=True)

        utils.replace_file(interface_file_path, value)

    @abc.abstractmethod

    def spawn_process(self):

        pass

class Dnsmasq(DhcpLocalProcess):

    # The ports that need to be opened when security policies are active

    # for users of this class.

    PORTS = {IPV4: [(UDP, DNS_PORT), (TCP, DNS_PORT), (UDP, DHCPV4_PORT)],

    _TAG_PREFIX = 'tag%d'

    @classmethod

    def check_version(cls):

    @classmethod

    def existing_dhcp_networks(cls, conf, root_helper):

        confs_dir = os.path.abspath(os.path.normpath(conf.dhcp_confs))

        return [

            c for c in os.listdir(confs_dir)

        ]

    def spawn_process(self):

        """Spawns a Dnsmasq process for the network."""

        env = {

        }

        cmd = [

            '/usr/lib/inet/dnsmasq',

            '--no-hosts',

            '--no-resolv',

            '--strict-order',

            '--bind-interfaces',

            '--interface=%s' % self.interface_name,

            '--except-interface=lo0',

            '--pid-file=%s' % self.get_conf_file_name(

                'pid', ensure_conf_dir=True),

            '--dhcp-hostsfile=%s' % self._output_hosts_file(),

            '--dhcp-optsfile=%s' % self._output_opts_file(),

            '--leasefile-ro',

        ]

        for i, subnet in enumerate(self.network.subnets):

            # if a subnet is specified to have dhcp disabled

            if not subnet.enable_dhcp:

                continue

            if subnet.ip_version == 4:

                mode = 'static'

            else:

                # TODO(gmoodalb): how do we indicate other options

                # ra-only, slaac, ra-nameservers, and ra-stateless.

                macaddr_cmd = ['/usr/sbin/dladm', 'show-linkprop',

                               '-co', 'value', '-p', 'mac-address',

                               self.interface_name]

                stdout = utils.execute(macaddr_cmd)

                uid = stdout.splitlines()[0].strip()

                # IANA assigned ID for Oracle

                enterprise_id = '111'

                cmd.append('--dhcp-duid=%s,%s' % (enterprise_id, uid))

                mode = 'static'

        cmd.append('--conf-file=%s' % self.conf.dnsmasq_config_file)

        if self.conf.dnsmasq_dns_server:

            cmd.append('--server=%s' % self.conf.dnsmasq_dns_server)

        if self.conf.dhcp_domain:

            cmd.append('--domain=%s' % self.conf.dhcp_domain)

    def reload_allocations(self):

        """Rebuild the dnsmasq config and signal the dnsmasq to reload."""

        # If all subnets turn off dhcp, kill the process.

        if not self._enable_dhcp():

            self.disable()

            LOG.debug(_('Killing dhcpmasq for network since all subnets have '

                        'turned off DHCP: %s'), self.network.id)

            return

        self._output_hosts_file()

        self._output_opts_file()

        if self.active:

            cmd = ['kill', '-HUP', self.pid]

        else:

            LOG.debug(_('Pid %d is stale, relaunching dnsmasq'), self.pid)

        LOG.debug(_('Reloading allocations for network: %s'), self.network.id)

    def _output_hosts_file(self):

        """Writes a dnsmasq compatible hosts file."""

        r = re.compile('[:.]')

        buf = StringIO.StringIO()

        for port in self.network.ports:

            for alloc in port.fixed_ips:

                name = 'host-%s.%s' % (r.sub('-', alloc.ip_address),

                                       self.conf.dhcp_domain)

        name = self.get_conf_file_name('host')

        utils.replace_file(name, buf.getvalue())

        return name

    def _output_opts_file(self):

        """Write a dnsmasq compatible options file."""

        options = []

        for i, subnet in enumerate(self.network.subnets):

            if not subnet.enable_dhcp:

                continue

            if subnet.dns_nameservers:

                options.append(

                    self._format_option(i, 'dns-server',

                                        ','.join(subnet.dns_nameservers)))

            if host_routes:

                options.append(

                    self._format_option(i, 'classless-static-route',

                                        ','.join(host_routes)))

            if subnet.ip_version == 4:

                else:

                    options.append(self._format_option(i, 'router'))

        name = self.get_conf_file_name('opts')

        utils.replace_file(name, '\n'.join(options))

        return name

    @classmethod

    def lease_update(cls):