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

    34

        if host.ip :

    35

            log.info("%s: forward %s[%s]: A %s", host, origin, label, host.ip)

    36

    37

            yield pvl.dns.ZoneRecord.A(label, host.ip)

    38

    39

        if host.ip6 :

    40

            log.info("%s: forward %s[%s]: AAAA %s", host, origin, label, host.ip6)

    41

    42

            yield pvl.dns.ZoneRecord.AAAA(label, host.ip6)

    43

    44

    else:

    45

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

    46

        return

    47

    48

    if host.location:

    49

        location_alias, location_domain = host.location

    50

    51

        try:

    52

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

    53

        except ValueError as error:

    54

            raise HostZoneError(host, error)

    55

    56

    for alias in host.alias:

    57

        try:

    58

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

    59

        except ValueError as error:

    60

            raise HostZoneError(host, error)

    61

    62

    for alias in host.alias4:

    63

        if not host.ip:

    64

            raise HostZoneError(host, "alias4={host.alias4} without ip=".format(host=host))

    65

    66

        try:

    67

            yield pvl.dns.ZoneRecord.A(pvl.dns.relative(origin, host.domain, alias), host.ip)

    68

        except ValueError as error:

    69

            raise HostZoneError(host, error)

    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

        try:

    76

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

    77

        except ValueError as error:

    78

            raise HostZoneError(host, error)

    79

    80

def host_reverse (host, prefix) :

    81

    """

    82

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

    83

    """

    84

    85

    if prefix.version == 4 :

    86

        ip = host.ip

    87

    88

        # reverse= is IPv4-only

    89

        reverse = host.reverse

    90

    91

    elif prefix.version == 6 :

    92

        ip = host.ip6

    93

    94

        # if reverse= is set, always omit, for lack of reverse6=

    95

        reverse = None if host.reverse is None else False

    96

    97

    else :

    98

        raise ValueError("%s: unknown ip version: %s" % (prefix, prefix.version))

    99

   100

    if not ip :

   101

        log.debug("%s: no ip%d", host, prefix.version)

   102

        return

   103

   104

    if ip not in prefix :

   105

        log.debug("%s: %s out of prefix: %s", host, ip, prefix)

   106

        return

   107

   108

    # relative label

   109

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

   110

   111

    if reverse:

   112

        alias = pvl.dns.fqdn(reverse)

   113

   114

        log.info("%s %s[%s]: CNAME %s", host, prefix, ip, alias)

   115

   116

        yield ip, pvl.dns.zone.ZoneRecord.CNAME(label, alias)

   117

   118

    elif reverse is None :

   119

        fqdn = host.fqdn()

   120

   121

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

   122

   123

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

   124

   125

    else:

   126

        log.info("%s %s[%s]: omit", host, prefix, ip)

   127

   131

    """

   132

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

   133

   134

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

   135

   140

        Yields ZoneRecords in Host-order

   141

    """

   142

   144

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

   145

   146

    by_name = dict()

   147

    by_name_type = dict()

   148

   149

    for host in hosts:

   150

        if not host.domain:

   151

            log.debug("%s: skip without domain", host)

   152

   153

        for rr in host_forward(host, origin) :

   154

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

   155

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

   156

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

   157

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

   158

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

   159

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

   160

   161

            by_name[rr.name] = rr

   162

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

   163

   164

            # preserve ordering

   165

            yield rr

   166

   171

    """

   172

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

   173

   179

        Yields ZoneRecords in IPAddress-order

   180

    """

   181

   184

   185

    # collect data for records

   186

    by_ip = dict()

   187

   188

    for host in hosts:

   189

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

   190

            if ip in by_ip :

   191

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

   192

   193

            # do not retain order

   194

            by_ip[ip] = rr

   195

   197

        # enumerate all of them

   198

        iter_ips = prefix.iterhosts()

   199

    else :

   200

        iter_ips = sorted(by_ip)

   201

   202

    for ip in iter_ips :

   203

        if ip in by_ip :

   204

            yield by_ip[ip]

   205

   207

            # synthesize a record

   208

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

   210

   212

   213

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

   214

   215

        else:

   216

            continue

   217