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 :

    56

            continue

    57

    59

            continue

    60

    62

    63

def process_hosts_reverse (options, hosts, prefix) :

    64

    """

    65

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

    66

    """

    67

    68

    # collect data for records

    69

    by_ip = dict()

    70

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

    71

        if ip in by_ip :

    72

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

    73

        else :

    74

            by_ip[ip] = fqdn

    75

    76

    if options.unknown_host :

    77

        # enumerate all of them

    78

        iter_ips = prefix.iterhosts()

    79

    else :

    80

        iter_ips = sorted(by_ip)

    81

    82

    for ip in iter_ips :

    83

        if ip in by_ip :

    84

            fqdn = by_ip[ip]

    85

        elif options.unknown_host :

    86

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

    87

        else :

    88

            fqdn = None

    89

    90

        if fqdn :

    91

            # reverse against the reverse-dns zone origin

    92

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

    93

    94

def apply_zone (options, zone) :

    95

    """

    96

        Output given ZoneRecord's

    97

    """

    98

    99

    for record in zone :

   100

        print unicode(record)

   101

   102

def main (argv) :

   103

    """

   104

        Generate bind zonefiles from host definitions.

   105

    """

   106

   107

    parser = optparse.OptionParser(main.__doc__)

   108

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

   109

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

   110

   111

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

   112

            help="Generate forward zone for domain")

   113

   114

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

   115

            help="Generate reverse zone for prefx")

   116

   117

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

   118

            help="Generate records for unused IPs")

   119

   120

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

   121

    pvl.args.apply(options)

   122

   123

    # input

   124

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

   125

   126

    # process

   127

    if options.forward_zone :

   128

        apply_zone(options, 

   129

                process_hosts_forward(options, hosts, options.forward_zone),

   130

        )

   131

   132

    if options.reverse_zone :

   133

        apply_zone(options, 

   134

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

   135

        )

   136

   137

if __name__ == '__main__':

   138

    pvl.args.main(main)