1

"""

     2

    Generate zonefile records from hosts

     3

"""

     4

     5

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

     6

import pvl.dns

     7

import pvl.hosts.host

     8

     9

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

    10

    pass

    11

    12

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

    13

def host_forward (host, origin):

    14

    """

    15

        Yield ZoneRecords for hosts within the given zone origin

    16

    """

    17

    18

    try:

    19

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

    20

    except ValueError as error:

    21

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

    22

        return

    23

    24

    if host.forward:

    25

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

    26

    27

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

    28

    29

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

    30

    31

    elif host.forward is None:

    32

        # forward

    33

        for sublabel, ip in host.addresses():

    34

            if sublabel:

    35

                sublabel = pvl.dns.join(sublabel, label)

    36

            else:

    37

                sublabel = label

    38

    39

            if ip.version == 4:

    40

                log.info("%s: ip: %s@%s A %s", host, sublabel, origin, ip)

    41

    42

                yield pvl.dns.ZoneRecord.A(sublabel, ip)

    43

    44

            elif ip.version == 6:

    45

                log.info("%s: ip6: %s@%s AAAA %s", host, label, origin, ip)

    46

    47

                yield pvl.dns.ZoneRecord.AAAA(sublabel, ip)

    48

    49

            else:

    50

                raise ValueError(ip)

    51

    52

    else:

    53

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

    54

        return

    55

    56

    if host.location:

    57

        location_alias, location_domain = host.location

    58

    59

        try:

    60

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

    61

        except ValueError as error:

    62

            raise HostZoneError(host, error)

    63

    64

    for alias in host.alias:

    65

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

    66

    67

    for alias in host.alias4:

    68

        if not host.ip4:

    69

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

    70

    71

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

    72

    73

    for alias in host.alias6:

    74

        if not host.ip6:

    75

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

    76

    77

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

    78

    79

def host_reverse (host, prefix) :

    80

    """

    82

    """

    83

    84

    for sublabel, ip in host.addresses():

    85

        if ip.version != prefix.version:

    86

            continue

    87

    88

        if ip not in prefix:

    89

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

    90

            continue

    91

    92

        if ip.version == 4:

    93

            # reverse= is IPv4-only

    94

            reverse = host.reverse

    95

    96

        elif prefix.version == 6:

    97

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

    98

            reverse = None if host.reverse is None else False

    99

   100

        # relative label

   101

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

   102

   103

        if reverse:

   104

            alias = pvl.dns.fqdn(reverse)

   105

   106

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

   107

   108

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

   109

   110

        elif reverse is None:

   111

            fqdn = host.fqdn()

   112

   113

            if sublabel:

   114

                fqdn = pvl.dns.join(sublabel, fqdn)

   115

   116

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

   117

   118

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

   119

   120

        else:

   121

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

   122

   123

def apply_hosts_forward (hosts, origin,

   124

        add_origin      = False,

   125

        check_conflicts = False,

   126

) :

   127

    """

   128

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

   129

   130

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

   131

   132

            hosts: [Host]       - Host's to render

   133

            origin: str         - generate records relative to given zone origin

   134

            add_origin: bool    - generate an explicit $ORIGIN directive

   135

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

   136

                                  overlapping CNAME records will always raise

   137

   138

        Yields ZoneRecords in Host-order

   139

    """

   140

   141

    if add_origin:

   142

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

   143

   144

    by_name = dict()

   145

    by_name_type = dict()

   146

   147

    for host in hosts:

   148

        for rr in host_forward(host, origin) :

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

   156

            by_name[rr.name] = host

   157

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

   158

   159

            # preserve ordering

   160

            yield rr

   161

   162

def apply_hosts_reverse (hosts, prefix,

   163

        unknown_host    = None,

   164

        unknown_domain  = None,

   165

) :

   166

    """

   167

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

   168

   169

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

   171

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

   172

            unknown_domain: str         - required if unknown_host is given

   173

   174

        Yields ZoneRecords in IPAddress-order

   175

    """

   176

   177

    if unknown_host and not unknown_domain:

   178

        raise ValueError("unknown_host requires unknown_domain=")

   179

   180

    # collect data for records

   181

    by_ip = dict()

   182

   183

    for host in hosts:

   184

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

   185

            if ip in by_ip :

   186

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

   187

   188

            # do not retain order

   189

            by_ip[ip] = rr

   190

   191

    if unknown_host :

   192

        # enumerate all of them

   194

    else :

   195

        iter_ips = sorted(by_ip)

   196

   197

    for ip in iter_ips :

   198

        if ip in by_ip :

   199

            yield by_ip[ip]

   200

   201

        elif unknown_host:

   202

            # synthesize a record

   203

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

   204

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

   205

   206

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

   207

   208

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

   209

   210

        else:

   211

            continue

   212