1

#!/usr/bin/env python

     2

     3

import pvl.args

     4

import pvl.hosts

     5

import pvl.dns.zone

     6

     7

import fnmatch

     8

import ipaddr

     9

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

    10

import optparse

    11

    13

    """

    35

    """

    36

    37

    for host in hosts :

    46

        else :

    48

            continue

    50

        if host.ip :

    52

    53

        if host.alias4 :

    55

    56

        if host.ip6 :

    58

    59

        if host.alias6 :

    61

    62

        for alias in host.alias :

    64

    65

        for alias4 in host.alias4 :

    67

    68

        for alias6 in host.alias6 :

    70

    71

def process_hosts_forward (options, hosts, domain) :

    72

    """

    73

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

    74

    """

    75

    76

    by_name = dict()

    77

    by_name_type = dict()

    78

    79

    # list of types thare are allowed to be present for a host

    80

    MULTI_TYPES = ('A', 'AAAA')

    81

    82

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

    83

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

    84

            raise ValueError("%s: duplicate name/type: %s: %s" % (rr.name, rr, by_name_type[(rr.name, rr.type)]))

    85

        elif rr.type in MULTI_TYPES :

    86

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

    87

        elif rr.name in by_name :

    88

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

    89

    90

        # always check these

    91

        by_name[rr.name] = rr

    92

    93

        # preserve ordering

    94

        yield rr

    95

    96

def process_hosts_ips (options, hosts, prefix) :

    97

    """

    98

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

    99

    """

   100

   101

    for host in hosts :

   102

        if prefix.version == 4 :

   103

            ip = host.ip

   104

        elif prefix.version == 6 :

   105

            ip = host.ip6

   106

        else :

   107

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

   108

   109

        if not ip :

   110

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

   111

            continue

   112

   113

        if ip not in prefix :

   114

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

   115

            continue

   116

   117

        fqdn = host.fqdn()

   118

   119

        log.debug("%s: ip=%s domain=%s: %s", host, ip, host.domain, fqdn)

   120

   121

        yield ip, fqdn

   122

   123

def process_hosts_reverse (options, hosts, prefix) :

   124

    """

   125

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

   126

    """

   127

   128

    # collect data for records

   129

    by_ip = dict()

   130

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

   131

        if ip in by_ip :

   132

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

   133

        else :

   134

            by_ip[ip] = fqdn

   135

   136

    if options.unknown_host :

   137

        # enumerate all of them

   138

        iter_ips = prefix.iterhosts()

   139

    else :

   140

        iter_ips = sorted(by_ip)

   141

   142

    for ip in iter_ips :

   143

        if ip in by_ip :

   144

            fqdn = by_ip[ip]

   145

        elif options.unknown_host :

   146

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

   147

        else :

   148

            fqdn = None

   149

   150

        log.info("%s: %s", ip, fqdn)

   151

   152

        if fqdn :

   153

            # reverse against the reverse-dns zone origin

   154

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

   155

   156

def apply_zone (options, zone) :

   157

    """

   158

        Output given ZoneRecord's

   159

    """

   160

   161

    for record in zone :

   162

        print unicode(record)

   163

   164

def main (argv) :

   165

    """

   166

        Generate bind zonefiles from host definitions.

   167

    """

   168

   169

    parser = optparse.OptionParser(main.__doc__)

   170

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

   171

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

   172

   173

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

   174

            help="Generate forward zone for domain")

   175

   176

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

   177

            help="Generate reverse zone for prefx")

   178

   179

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

   180

            help="Generate records for unused IPs")

   181

   182

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

   183

    pvl.args.apply(options)

   184

   185

    # input

   186

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

   187

   188

    # process

   189

    if options.forward_zone :

   190

        apply_zone(options, 

   191

                process_hosts_forward(options, hosts, options.forward_zone),

   192

        )

   193

   194

    if options.reverse_zone :

   195

        apply_zone(options, 

   196

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

   197

        )

   198

   199

if __name__ == '__main__':

   200

    pvl.args.main(main)