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

    @classmethod

    15

    def load (cls, file) :

    16

        return cls().parse_file(file)

    17

    18

    def __init__ (self) :

    19

        self.stack = []

    20

        self.block = None

    21

        self.items = []

    22

        self.blocks = []

    23

    24

    @classmethod

    25

    def split (cls, line) :

    26

        """

    27

            Split given line-data.

    28

    29

            >>> split = DHCPConfigParser.split

    30

            >>> split('foo bar')

    31

            ['foo', 'bar']

    32

            >>> split('"foo"')

    33

            ['foo']

    34

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

    35

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

    36

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

    37

            ['foo', 'asdf quux']

    38

        """

    39

    40

        # parse out one str

    41

        if '"' in line :

    42

            log.debug("%s", line)

    43

    44

            # crude

    45

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

    46

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

    47

    48

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

    49

        else :

    50

            return line.split()

    51

    52

    @classmethod

    53

    def lex (self, line) :

    54

        """

    55

            Yield tokens from the given lines.

    56

    57

            >>> lex = DHCPConfigParser.lex

    58

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

    59

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

    60

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

    61

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

    62

    63

        """

    64

    65

        log.debug("%s", line)

    66

    67

        # comments?

    68

        if '#' in line :

    69

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

    70

        else :

    71

            comment = None

    72

    73

        # clean?

    74

        line = line.strip()

    75

    76

        # parse

    77

        if not line :

    78

            # ignore, empty/comment

    79

            return

    80

    81

        elif line.startswith('uid') :

    82

            # XXX: too hard to parse properly

    83

            return

    84

    85

        elif '{' in line :

    86

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

    87

    88

            # we are in a new decl

    89

            yield 'open', self.split(decl)

    90

    91

        elif ';' in line :

    92

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

    93

    94

            # a stanza

    95

            yield 'item', self.split(param)

    96

    97

        elif '}' in line :

    98

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

    99

   100

            if close.strip() :

   101

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

   102

   103

            # end

   104

            yield 'close', None

   105

   106

        else :

   107

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

   108

            return

   109

   110

        # got the whole line?

   111

        if line.strip() :

   112

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

   113

   114

    def push_block (self, block) :

   115

        """

   116

            Open new block.

   117

        """

   118

   119

        self.stack.append((self.block, self.items, self.blocks))

   120

   121

        self.block = block

   122

        self.items = []

   123

        self.blocks = []

   124

   125

    def feed_item (self, item) :

   126

        """

   127

            Add item to block

   128

        """

   129

   130

        self.items.append(item)

   131

   132

    def pop_block (self) :

   133

        """

   134

            Close block. Returns

   135

                (block, [items])

   136

        """

   137

   138

        assert self.block

   139

   140

        block = (self.block, self.items, self.blocks)

   141

   142

        self.block, self.items, self.blocks = self.stack.pop(-1)

   143

   144

        self.blocks.append(block)

   145

   146

        return block

   147

   148

    def parse_line (self, line) :

   149

        """

   150

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

   151

   152

            Yields (block, [ lines ]) tuples.

   153

   154

            >>> parser = DHCPConfigParser()

   155

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

   156

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

   157

   158

            >>> parser = DHCPConfigParser()

   159

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

   160

            []

   161

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

   162

            []

   163

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

   164

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

   165

        """

   166

   167

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

   168

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

   169

   170

            if token == 'open' :

   171

                # open new block

   172

                block = args

   173

   174

                if self.block :

   175

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

   176

                else :

   177

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

   178

   179

                self.push_block(block)

   180

   181

            elif token == 'close' :

   182

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

   183

   184

                # collected block items

   185

                yield self.pop_block()

   186

   187

            # must be within block!

   188

            elif token == 'item' :

   189

                item = args

   190

   191

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

   192

                self.feed_item(item)

   193

   194

            else :

   195

                # ???

   196

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

   197

   198

    def parse_lines (self, lines) :

   199

        """

   200

            Trivial wrapper around parse to parse multiple lines.

   201

        """

   202

   203

        for line in lines :

   204

            for item in self.parse_line(line) :

   205

                yield item

   206

   207

    def parse_file (self, file) :

   208

        """

   209

            Parse an entire file, returning (items, blocks) lists.

   210

   211

            >>> DHCPConfigParser().parse_file(['foo;', 'barfoo {', 'bar;', '}'])

   212

            ([['foo']], [(['barfoo'], [['bar']], [])])

   213

        """

   214

   215

        for line in file :

   216

            for item in self.parse_line(line) :

   217

                log.debug("%s", item)

   218

   219

        assert not self.block

   220

   221

        return self.items, self.blocks