1

#!/usr/bin/env python

     2

     3

import pvl.args

     4

import pvl.hosts

     5

import pvl.dns.zone

     6

     7

import ipaddr

     8

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

     9

import optparse

    10

    11

def process_hosts_names (options, hosts, domain) :

    12

    """

    13

        Yield ZoneRecords for the given domain's hosts.

    14

    """

    15

    16

    for host in hosts :

    17

        if options.forward_zone and host.domain != domain :

    18

            continue

    19

    20

        if host.ip :

    21

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

    22

    23

        for alias in host.alias :

    24

            yield pvl.dns.zone.ZoneRecord.CNAME(alias, host)

    25

    26

def process_hosts_forward (options, hosts, domain) :

    27

    """

    28

        Generate DNS ZoneRecords for the given domain's zone for hosts.

    29

    """

    30

    31

    by_name = dict()

    32

    33

    for rr in process_hosts_names(options, hosts, domain) :

    34

        if rr.name in by_name :

    35

            raise ValueError("%s: duplicate name: %s: %s" % (rr.name, rr, by_name[rr.name]))

    36

        else :

    37

            by_name[rr.name] = rr

    38

    39

        # preserve ordering

    40

        yield rr

    41

    42

def process_hosts_ips (options, hosts, prefix) :

    43

    """

    44

        Yield (ip, fqnd) for hosts within given prefix.

    45

    """

    46

    47

    for host in hosts :

    48

        if not host.ip :

    49

            continue

    50

    51

        if host.ip not in prefix :

    52

            continue

    53

    54

        yield host.ip, pvl.dns.zone.fqdn(host, host.domain)

    55

    56

def process_hosts_reverse (options, hosts, prefix) :

    57

    """

    58

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

    59

    """

    60

    61

    # collect data for records

    62

    by_ip = dict()

    63

    for ip, fqdn in process_hosts_ips(options, hosts, prefix) :

    64

        if ip in by_ip :

    65

            raise ValueError("%s: duplicate ip: %s: %s" % (fqdn, ip, by_ip[ip]))

    66

        else :

    67

            by_ip[ip] = fqdn

    68

    76

        if ip in by_ip :

    77

            fqdn = by_ip[ip]

    78

        elif options.unknown_host :

    79

            fqdn = pvl.dns.zone.fqdn(options.unknown_host, options.hosts_domain)

    80

        else :

    81

            fqdn = None

    82

    83

        if fqdn :

    84

            # reverse against the reverse-dns zone origin

    85

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

    86

    87

def apply_zone (options, zone) :

    88

    """

    89

        Output given ZoneRecord's

    90

    """

    91

    92

    for record in zone :

    93

        print unicode(record)

    94

    95

def main (argv) :

    96

    """

    97

        Generate bind zonefiles from host definitions.

    98

    """

    99

   100

    parser = optparse.OptionParser(main.__doc__)

   101

    parser.add_option_group(pvl.args.parser(parser))

   102

    parser.add_option_group(pvl.hosts.optparser(parser))

   103

   104

    parser.add_option('--forward-zone',         metavar='DOMAIN',

   105

            help="Generate forward zone for domain")

   106

   107

    parser.add_option('--reverse-zone',         metavar='PREFIX',

   108

            help="Generate reverse zone for prefx")

   109

   110

    parser.add_option('--unknown-host',         metavar='NAME',

   111

            help="Generate records for unused IPs")

   112

   113

    options, args = parser.parse_args(argv[1:])

   114

    pvl.args.apply(options)

   115

   116

    # input

   117

    hosts = pvl.hosts.apply(options, args)

   118

   119

    # process

   120

    if options.forward_zone :

   121

        apply_zone(options, 

   122

                process_hosts_forward(options, hosts, options.forward_zone),

   123

        )

   124

   125

    if options.reverse_zone :

   126

        apply_zone(options, 

   127

                process_hosts_reverse(options, hosts, ipaddr.IPNetwork(options.reverse_zone)),

   128

        )

   129

   130

if __name__ == '__main__':

   131

    pvl.args.main(main)