1

"""

     2

    Generate zonefile records from hosts

     3

"""

     4

     5

import ipaddr

     6

import logging; log = logging.getLogger('pvl.hosts.zone')

     7

import pvl.dns

     8

import pvl.hosts.host

     9

    10

class HostZoneError(pvl.hosts.host.HostError):

    11

    pass

    12

    13

# TODO: generate location alias CNAMEs even if host itself is outside origin?

    14

def host_forward (host, origin):

    15

    """

    16

        Yield ZoneRecords for hosts within the given zone origin

    17

    """

    18

    19

    try:

    20

        label = pvl.dns.relative(origin, host.domain, host.name)

    21

    except ValueError as error:

    22

        log.info("%s: skip: %s", host, error)

    23

        return

    24

    25

    if host.forward:

    26

        forward = pvl.dns.fqdn(host.forward)

    27

    28

        log.info("%s: forward: %s", host, forward)

    29

    30

        yield pvl.dns.ZoneRecord.CNAME(label, forward)

    31

    32

    elif host.forward is None:

    33

        # forward

    42

    44

    47

    49

    50

    else:

    51

        log.info("%s: skip forward", host)

    52

        return

    53

    54

    if host.location:

    55

        location_alias, location_domain = host.location

    56

    57

        try:

    58

            yield pvl.dns.ZoneRecord.CNAME(pvl.dns.relative(origin, location_domain, location_alias), label)

    59

        except ValueError as error:

    60

            raise HostZoneError(host, error)

    61

    62

    for alias in host.alias:

    63

        yield pvl.dns.ZoneRecord.CNAME(pvl.dns.relative(origin, host.domain, alias), label)

    64

    65

    for alias in host.alias4:

    68

    70

    71

    for alias in host.alias6:

    72

        if not host.ip6:

    73

            raise HostZoneError(host, "alias6={host.alias6} without ip6=".format(host=host))

    74

    75

        yield pvl.dns.ZoneRecord.AAAA(pvl.dns.relative(origin, host.domain, alias), host.ip6)

    76

    77

def host_reverse (host, prefix) :

    78

    """

    79

        Yield (ipaddr.IPAddress, ZoneRecord) tuples for host within given prefix's reverse-dns zone.

    80

    """

    88

    94

    97

   101

   113

   129

def apply_hosts_forward (hosts, origin,

   130

        add_origin      = False,

   131

        check_conflicts = False,

   132

) :

   133

    """

   134

        Generate DNS ZoneRecords for for hosts within the given zone origin.

   135

   136

        Verifies that there are no overlapping name/type records, or CNAME records from aliases.

   137

   138

            hosts: [Host]       - Host's to render

   139

            origin: str         - generate records relative to given zone origin

   140

            add_origin: bool    - generate an explicit $ORIGIN directive

   141

            check_conflits: bool- raise HostZoneError on dupliate records for the same name/type

   142

                                  overlapping CNAME records will always raise

   143

   144

        Yields ZoneRecords in Host-order

   145

    """

   146

   147

    if add_origin:

   148

        yield pvl.dns.ZoneDirective.build('ORIGIN', pvl.dns.fqdn(origin))

   149

   150

    by_name = dict()

   151

    by_name_type = dict()

   152

   153

    for host in hosts:

   154

        for rr in host_forward(host, origin) :

   155

            if (rr.name, 'CNAME') in by_name_type:

   156

                raise HostZoneError(host, u"{cname} CNAME conflict with {other}".format(cname=rr.name, other=by_name_type[rr.name, 'CNAME']))

   157

            elif rr.type == 'CNAME' and rr.name in by_name:

   158

                raise HostZoneError(host, u"{cname} CNAME conflict with {other}".format(cname=rr.name, other=by_name[rr.name]))

   159

            elif check_conflicts and (rr.name, rr.type) in by_name_type:

   160

                raise HostZoneError(host, u"{name} {type} conflict with {other}".format(type=rr.type, name=rr.name, other=by_name_type[rr.name, rr.type]))

   161

   162

            by_name[rr.name] = host

   163

            by_name_type[rr.name, rr.type] = host

   164

   165

            # preserve ordering

   166

            yield rr

   167

   168

def apply_hosts_reverse (hosts, prefix,

   169

        unknown_host    = None,

   170

        unknown_domain  = None,

   171

) :

   172

    """

   173

        Generate DNS ZoneRecords within the given prefix's reverse-dns zone for hosts.

   174

   175

            hosts: [Host]               - Host's to render PTRs for

   176

            prefix: ipaddr.IPNetwork    - IPv4/IPv6 prefix to render PTRs for within associated in-addr.arpa/ip6.arpa zone

   177

            unknown_host: str           - render a PTR to the given host @unknown_domain for unassigned IPs within prefix

   178

            unknown_domain: str         - required if unknown_host is given

   179

   180

        Yields ZoneRecords in IPAddress-order

   181

    """

   182

   183

    if unknown_host and not unknown_domain:

   184

        raise ValueError("unknown_host requires unknown_domain=")

   185

   186

    # collect data for records

   187

    by_ip = dict()

   188

   189

    for host in hosts:

   190

        for ip, rr in host_reverse(host, prefix) :

   191

            if ip in by_ip :

   192

                raise HostZoneError(host, "{host}: IP {ip} conflict: {other}".format(host=host, ip=ip, other=by_ip[ip]))

   193

   194

            # do not retain order

   195

            by_ip[ip] = rr

   196

   197

    if unknown_host :

   198

        # enumerate all of them

   199

        iter_ips = prefix.iterhosts()

   200

    else :

   201

        iter_ips = sorted(by_ip)

   202

   203

    for ip in iter_ips :

   204

        if ip in by_ip :

   205

            yield by_ip[ip]

   206

   207

        elif unknown_host:

   208

            # synthesize a record

   209

            label = pvl.dns.reverse_label(prefix, ip)

   210

            fqdn = pvl.dns.fqdn(unknown_host, unknown_domain)

   211

   212

            log.info("%s %s[%s]: unused PTR %s", unknown_host, ip, prefix, fqdn)

   213

   214

            yield pvl.dns.ZoneRecord.PTR(label, fqdn)

   215

   216

        else:

   217

            continue

   218