1

"""

     2

    Simple parser for ISC dhcpd config files.

     3

"""

     4

     5

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

     6

     7

class DHCPConfigParser (object) :

     8

    """

     9

        Simplistic parser for a dhcpd.leases file.

    10

    11

        Doesn't implement the full spec, but a useful approximation.

    12

    """

    13

    14

    def __init__ (self) :

    15

        self.block = None

    16

        self.items = []

    17

    18

    @classmethod

    19

    def split (cls, line) :

    20

        """

    21

            Split given line-data.

    22

    23

            >>> split = DHCPLeasesParser.split

    24

            >>> split('foo bar')

    25

            ['foo', 'bar']

    26

            >>> split('"foo"')

    27

            ['foo']

    28

            >>> split('foo "asdf quux" bar')

    29

            ['foo', 'asdf quux', 'bar']

    30

            >>> split('foo "asdf quux"')

    31

            ['foo', 'asdf quux']

    32

        """

    33

    34

        # parse out one str

    35

        if '"' in line :

    36

            log.debug("%s", line)

    37

    38

            # crude

    39

            pre, line = line.split('"', 1)

    40

            data, post = line.rsplit('"', 1)

    41

    42

            return pre.split() + [data] + post.split()

    43

        else :

    44

            return line.split()

    45

    46

    @classmethod

    47

    def lex (self, line) :

    48

        """

    49

            Yield tokens from the given lines.

    50

    51

            >>> lex = DHCPLeasesParser.lex

    52

            >>> list(lex('foo;'))

    53

            [('item', ['foo'])]

    54

            >>> list(item for line in ['foo {', ' bar;', '}'] for item in lex(line))

    55

            [('open', ['foo']), ('item', ['bar']), ('close', None)]

    56

    57

        """

    58

    59

        log.debug("%s", line)

    60

    61

        # comments?

    62

        if '#' in line :

    63

            line, comment = line.split('#', 1)

    64

        else :

    65

            comment = None

    66

    67

        # clean?

    68

        line = line.strip()

    69

    70

        # parse

    71

        if not line :

    72

            # ignore, empty/comment

    73

            return

    74

    75

        elif line.startswith('uid') :

    76

            # XXX: too hard to parse properly

    77

            return

    78

    79

        elif '{' in line :

    80

            decl, line = line.split('{', 1)

    81

    82

            # we are in a new decl

    83

            yield 'open', self.split(decl)

    84

    85

        elif ';' in line :

    86

            param, line = line.split(';', 1)

    87

    88

            # a stanza

    89

            yield 'item', self.split(param)

    90

    91

        elif '}' in line :

    92

            close, line = line.split('}', 1)

    93

    94

            if close.strip() :

    95

                log.warn("Predata on close: %s", close)

    96

    97

            # end

    98

            yield 'close', None

    99

   100

        else :

   101

            log.warn("Unknown line: %s", line)

   102

            return

   103

   104

        # got the whole line?

   105

        if line.strip() :

   106

            log.warn("Data remains: %s", line)

   107

   108

    def push_block (self, block) :

   109

        """

   110

            Open new block.

   111

        """

   112

   113

        # XXX: stack

   114

        assert not self.block

   115

   116

        self.block = block

   117

        self.items = []

   118

   119

    def feed_block (self, item) :

   120

        """

   121

            Add item to block

   122

        """

   123

   124

        assert self.block

   125

   126

        self.items.append(item)

   127

   128

    def pop_block (self) :

   129

        """

   130

            Close block. Returns

   131

                (block, [items])

   132

        """

   133

   134

        assert self.block

   135

   136

        block, items = self.block, self.items

   137

   138

        self.block = None

   139

        self.items = None

   140

   141

        return block, items

   142

   143

    def parse (self, line) :

   144

        """

   145

            Parse given line, yielding any complete blocks that come out.

   146

   147

            Yields (block, [ lines ]) tuples.

   148

   149

            >>> parser = DHCPLeasesParser()

   150

            >>> list(parser.parse_lines(['foo {', ' bar;', ' quux asdf;', '}']))

   151

            [(['foo'], [['bar'], ['quux', 'asdf']])]

   152

   153

            >>> parser = DHCPLeasesParser()

   154

            >>> list(parser.parse('foo {'))

   155

            []

   156

            >>> list(parser.parse_lines([' bar;', ' quux asdf;']))

   157

            []

   158

            >>> list(parser.parse('}'))

   159

            [(['foo'], [['bar'], ['quux', 'asdf']])]

   160

        """

   161

   162

        for token, args in self.lex(line) :

   163

            #log.debug("%s: %s [block=%s]", token, args, self.block)

   164

   165

            if token == 'open' :

   166

                # open new block

   167

                block = args

   168

   169

                if self.block :

   170

                    log.warn("nested blocks: %s > %s", self.block, block)

   171

                    continue

   172

   173

                log.debug("open block: %s", block)

   174

                self.push_block(block)

   175

   176

            elif token == 'close' :

   177

                log.debug("close block: %s", self.block)

   178

   179

                # collected block items

   180

                yield self.pop_block()

   181

   182

            # must be within block!

   183

            elif token == 'item' :

   184

                item = args

   185

   186

                if not self.block :

   187

                    log.warn("token outside block: %s: %s", token, args)

   188

                    continue

   189

   190

                log.debug("block %s item: %s", self.block, item)

   191

                self.feed_block(item)

   192

   193

            else :

   194

                # ???

   195

                raise KeyError("Unknown token: {0}: {1}".format(token, args))

   196

   197

    def parse_lines (self, lines) :

   198

        """

   199

            Trivial wrapper around parse to parse multiple lines.

   200

        """

   201

   202

        for line in lines :

   203

            for item in self.parse(line) :

   204

                yield item

   205

   206