1

#!/usr/bin/env python

     2

     3

"""

     4

    Process dhcpd configs.

     5

     6

    Takes a conf file as input, and gives a conf file as output.

     7

"""

     8

     9

import pvl.args

    10

import pvl.dhcp.config

    11

    12

import os.path

    13

import optparse

    14

import logging; log = logging.getLogger('pvl.dhcp-conf')

    15

    16

def apply_input (options, conf) :

    17

    """

    18

        Parse (items, blocks) from given dhcp.conf path.

    19

    """

    20

    21

    file = pvl.args.apply_file(conf, 'r')

    22

    return pvl.dhcp.config.DHCPConfigParser.load(file)

    23

    24

QUOTE_ITEMS = set((

    25

    'filename',

    26

))

    27

    28

def process_dhcp_items (options, block, items) :

    29

    """

    30

        Yield items for output from given input items

    31

    """

    32

    33

    for item in items :

    34

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

    35

    36

        log.debug("%s: %s: %s", block, name, args)

    37

    38

        if name == 'include' :

    39

            include, = args

    40

    41

            if options.include_path :

    42

                include = os.path.join(options.include_path, include)

    43

                log.info("include: %s", include)

    44

    45

            yield 'include', '"{include}"'.format(include=include)

    46

    47

        elif name in QUOTE_ITEMS :

    48

            yield name, ' '.join('"{arg}"'.format(arg=arg) for arg in args)

    49

    50

        else :

    51

            yield item

    52

    53

def process_dhcp_block (options, block, items, blocks) :

    54

    """

    55

        Yield block for output for given input block.

    56

    """

    57

    58

    log.debug("%s -> %s %s", block, items, blocks)

    59

    60

    items = list(process_dhcp_items(options, block, items))

    61

    blocks = [process_dhcp_block(options, subblock, subitems, subblocks) for subblock, subitems, subblocks in blocks]

    62

    63

    log.debug("%s <- %s %s", block, items, blocks)

    64

    65

    return block, items, blocks

    66

    67

def process_dhcp_conf (options, conf) :

    68

    """

    69

        Yield (items, blocks) for output for given input (items, blocks).

    70

    """

    71

    items, blocks = conf

    72

    73

    log.debug("-> %s %s", items, blocks)

    74

    75

    _, items, blocks = process_dhcp_block(options, None, items, blocks)

    76

    77

    log.debug("<- %s %s", items, blocks)

    78

    79

    return items, blocks

    80

    81

def process_output (options, items, blocks) :

    82

    """

    83

        Generate output lines from given (items, blocks).

    84

    """

    85

    86

    for item in items :

    87

        yield '\t'.join(item) + ';'

    88

    89

    for block, subitems, subblocks in blocks :

    90

        yield ' '.join(block) + ' {'

    91

        for line in process_output(options, subitems, subblocks) :

    92

            yield '\t' + line

    93

        yield '}'

    94

    95

def apply_output (options, conf) :

    96

    """

    97

        Write output line for given (items, blocks) to --output-conf.

    98

    """

    99

   100

    file = pvl.args.apply_file(options.output_conf, 'w')

   101

   102

    items, blocks = conf

   103

   104

    for line in process_output(options, items, blocks) :

   105

        print >>file, line

   106

   107

def main (argv) :

   108

    parser = optparse.OptionParser(__doc__)

   109

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

   110

   111

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

   112

            help="Output conf to file; default stdout")

   113

    parser.add_option('--include-path',         metavar='PATH',

   114

            help="Adjust includes to use given path prefix")

   115

   116

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

   117

    pvl.args.apply(options)

   118

   119

    for conf in args :

   120

        # input

   121

        conf = apply_input(options, conf)

   122

   123

        # process

   124

        conf = process_dhcp_conf(options, conf)

   125

   126

        # output

   127

        apply_output(options, conf)

   128

   129

if __name__ == '__main__':

   130

    pvl.args.main(main)