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

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

    58

    59

    for alias in host.alias4:

    60

        if not host.ip:

    61

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

    62

    63

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

    64

    65

    for alias in host.alias6:

    66

        if not host.ip6:

    67

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

    68

    69

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

    70

    71

def host_reverse (host, prefix) :

    72

    """

    73

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

    74

    """

    75

    76

    if prefix.version == 4 :

    77

        ip = host.ip

    78

    79

        # reverse= is IPv4-only

    80

        reverse = host.reverse

    81

    82

    elif prefix.version == 6 :

    83

        ip = host.ip6

    84

    85

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

    86

        reverse = None if host.reverse is None else False

    87

    88

    else :

    89

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

    90

    91

    if not ip :

    92

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

    93

        return

    94

    95

    if ip not in prefix :

    96

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

    97

        return

    98

    99

    # relative label

   100

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

   101

   102

    if reverse:

   103

        alias = pvl.dns.fqdn(reverse)

   104

   105

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

   106

   107

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

   108

   109

    elif reverse is None :

   110

        fqdn = host.fqdn()

   111

   112

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

   113

   114

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

   115

   116

    else:

   117

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

   118

   119

def apply_hosts_forward (hosts, origin,

   120

        add_origin  = False,

   121

) :

   122

    """

   123

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

   124

   125

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

   126

   127

            hosts: [Host]       - Host's to render

   128

            origin: str         - generate records relative to given zone origin

   129

            add_origin: bool    - generate an explicit $ORIGIN directive

   130

   131

        Yields ZoneRecords in Host-order

   132

    """

   133

   134

    if add_origin:

   136

   137

    by_name = dict()

   138

    by_name_type = dict()

   139

   140

    for host in hosts:

   141

        for rr in host_forward(host, origin) :

   142

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

   143

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

   144

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

   145

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

   146

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

   147

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

   148

   149

            by_name[rr.name] = rr

   150

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

   151

   152

            # preserve ordering

   153

            yield rr

   154

   155

def apply_hosts_reverse (hosts, prefix,

   156

        unknown_host    = None,

   157

        unknown_domain  = None,

   158

) :

   159

    """

   160

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

   161

   162

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

   163

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

   164

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

   165

            unknown_domain: str         - required if unknown_host is given

   166

   167

        Yields ZoneRecords in IPAddress-order

   168

    """

   169

   170

    if unknown_host and not unknown_domain:

   171

        raise ValueError("unknown_host requires unknown_domain=")

   172

   173

    # collect data for records

   174

    by_ip = dict()

   175

   176

    for host in hosts:

   177

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

   178

            if ip in by_ip :

   179

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

   180

   181

            # do not retain order

   182

            by_ip[ip] = rr

   183

   184

    if unknown_host :

   185

        # enumerate all of them

   186

        iter_ips = prefix.iterhosts()

   187

    else :

   188

        iter_ips = sorted(by_ip)

   189

   190

    for ip in iter_ips :

   191

        if ip in by_ip :

   192

            yield by_ip[ip]

   193

   194

        elif unknown_host:

   195

            # synthesize a record

   196

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

   197

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

   198

   199

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

   200

   201

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

   202

   203

        else:

   204

            continue

   205