1

#!/usr/bin/env python

     2

     3

"""

     4

    Manipulate host definitions for dns/dhcp.

     5

"""

     6

     7

import pvl.args, optparse

     8

import pvl.dns.zone

     9

import pvl.dhcp.config

    10

    11

import collections

    12

import re

    13

import logging; log = logging.getLogger('main')

    14

    15

__version__ = '0.1'

    16

    17

def parse_options (argv) :

    18

    """

    19

        Parse command-line arguments.

    20

    """

    21

    22

    parser = optparse.OptionParser(

    23

            prog        = argv[0],

    24

            usage       = '%prog: [options]',

    25

            version     = __version__,

    26

    27

            # module docstring

    28

            description = __doc__,

    29

    )

    30

    31

    # logging

    32

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

    33

    34

    parser.add_option('-c', '--input-charset',  metavar='CHARSET',  default='utf-8', 

    35

            help="Encoding used for input files")

    36

    37

    parser.add_option('--output-charset',       metavar='CHARSET',  default='utf-8', 

    38

            help="Encoding used for output files")

    39

    40

    # input

    41

    parser.add_option('--import-zone-hosts',    metavar='FILE',

    42

            help="Load hosts from DNS zone")

    43

    44

    parser.add_option('--import-dhcp-hosts',    metavar='FILE',

    45

            help="Load hosts from DHCP config")

    46

    47

    # defaults

    48

    parser.add_option('--hosts-domain',         metavar='DOMAIN',

    49

            help="Default domain for hosts")

    50

    51

    parser.add_option('--zone-unused',          metavar='HOST',

    52

            help="DNS name for unallocated hosts")

    53

    54

    # output

    55

    parser.add_option('--output-hosts',         metavar='FILE',

    56

            help="Output hosts file")

    57

    58

    # defaults

    59

    parser.set_defaults(

    60

    61

    )

    62

    63

    # parse

    64

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

    65

    66

    # apply

    67

    pvl.args.apply(options, argv[0])

    68

    69

    return options, args

    70

    71

def process_zone_hosts (options, file) :

    72

    """

    73

        Yield host info from zonefile records.

    74

    """

    75

    76

    for rr in pvl.dns.zone.ZoneRecord.load(file) :

    77

        if options.zone_unused and rr.name == options.zone_unused :

    78

            log.debug("%s: skip %s", rr.name, rr)

    79

            continue

    80

    81

        elif rr.type == 'A' :

    82

            ip, = rr.data

    83

    84

            yield rr.name, 'ip', ip

    85

    86

            if rr.comment :

    88

    89

        elif rr.type == 'CNAME' :

    90

            host, = rr.data

    91

    92

            yield host, 'alias', rr.name

    93

    94

        else :

    95

            log.warn("%s: unknown rr: %s", rr.name, rr)

    96

    97

def process_dhcp_host (options, host, items) :

    98

    """

    99

        Yield host infos from a dhcp host ... { ... }

   100

    """

   101

   102

    hostname = None

   103

    ethernet = []

   104

    fixed_address = None

   105

   106

    for item in items :

   107

        item, args = item[0], item[1:]

   108

   109

        if item == 'hardware' :

   110

            _ethernet, ethernet = args

   111

            assert _ethernet == 'ethernet'

   112

        elif item == 'fixed-address' :

   113

            fixed_address, = args

   114

        elif item == 'option' :

   115

            option = args.pop(0)

   116

   117

            if option == 'host-name' :

   118

                hostname, = args

   119

            else :

   120

                log.warn("host %s: ignore unknown option: %s", host, option)

   121

        else :

   122

            log.warn("host %s: ignore unknown item: %s", host, item)

   123

   124

    # determine hostname

   125

    if hostname :

   126

        pass

   127

    elif fixed_address and not re.match(r'\d+\.\d+\.\d+.\d+', fixed_address) :

   128

        hostname, domain = fixed_address.split('.', 1)

   129

    elif '-' in host :

   130

        hostname, suffix = host.rsplit('-', 1)

   131

    else :

   132

        log.warn("%s: guess hostname: %s", host, host)

   133

        hostname = host

   134

   135

    if hostname :

   136

        yield hostname, 'ethernet', ethernet

   137

   138

def process_dhcp_hosts (options, blocks) :

   139

    """

   140

        Process hosts from a parsed block

   141

    """

   142

   143

    for block, items, blocks in blocks :

   144

        log.info("%s", block)

   145

   146

        block, args = block[0], block[1:]

   147

   148

        if block == 'group' :

   149

            for info in process_dhcp_hosts(options, blocks) :

   150

                yield info

   151

        elif block == 'host' :

   152

            host, = args

   153

   154

            try :

   155

                for info in process_dhcp_host(options, host, items) :

   156

                    yield info

   157

            except ValueError as error :

   158

                log.warn("%s: invalid host: %s", host, error)

   159

        else:

   160

            log.warn("ignore unknown block: %s", block)

   161

   162

def process_dhcp_conf (options, file) :

   163

    items, blocks = pvl.dhcp.config.DHCPConfigParser().load(file)

   164

   165

    for item in items :

   166

        item, args = item[0], item[1:]

   167

   168

        if item == 'include' :

   169

            include, = args

   170

            for info in process_dhcp_conf(options, pvl.args.apply_file(include)) :

   171

                yield info

   172

        else :

   173

            log.warn("ignore unknown item: %s", item)

   174

   175

    for info in process_dhcp_hosts(options, blocks) :

   176

        yield info

   177

   178

def apply_hosts_import (options) :

   179

    """

   180

        Import host infos from given files.

   181

    """

   182

   183

    if options.import_zone_hosts:

   184

        for info in process_zone_hosts(options,

   185

                pvl.args.apply_file(options.import_zone_hosts)) :

   186

            yield info

   187

   188

    if options.import_dhcp_hosts:

   189

        for info in process_dhcp_conf(options,

   190

                pvl.args.apply_file(options.import_dhcp_hosts)) :

   191

            yield info

   259

def process_hosts_import (options, import_hosts) :

   260

    """

   261

        Import host definitions from given infos

   262

    """

   263

   264

    hosts = collections.defaultdict(lambda: collections.defaultdict(list))

   265

   266

    for host, field, value in import_hosts :

   267

        hosts[host][field].append(value)

   268

   269

    return hosts.iteritems()

   270

   271

   272

def main (argv) :

   273

    options, args = parse_options(argv)

   274

   275

    if args :

   276

        # direct from file

   277

        hosts = pvl.args.apply_files(args, 'r', options.input_charset)

   278

    else :

   279

        # import

   280

        import_hosts = apply_hosts_import(options)

   282

        hosts = process_hosts_import(options, import_hosts)

   283

   284

    # output

   285

    if options.output_hosts :

   286

        for host, fields in hosts :

   287

            print host

   288

   289

            for field, values in fields.iteritems() :

   290

                for value in values :

   291

                    print "\t", field, "\t", value.encode(options.output_charset)

   292

   293

    return 0

   294

   295

if __name__ == '__main__':

   296

    pvl.args.main(main)