1

import logging

     2

     3

log = logging.getLogger('pvl.dns.generate')

     4

     5

class OffsetValue (object) :

     6

    """

     7

        Magic for $GENERATE offsets.

     8

     9

        >>> OffsetValue(0)[1]

    10

        1

    11

        >>> OffsetValue(10)[5]

    12

        15

    13

    """

    14

    15

    def __init__ (self, base) :

    16

        self.base = base

    17

    18

    def __getitem__ (self, offset) :

    19

        return self.base + offset

    20

    21

def parse_generate_field (field) :

    22

    """

    23

        Parse a $GENERATE lhs/rhs field:

    24

            $

    25

            ${<offset>[,<width>[,<base>]]}

    26

            \$

    27

            $$

    28

    29

        Returns a wrapper that builds the field-value when called with the index.

    30

    31

        >>> parse_generate_field("foo")(1)

    32

        'foo'

    33

        >>> parse_generate_field("foo-$")(1)

    34

        'foo-1'

    35

        >>> parse_generate_field("foo-$$")(1)

    36

        'foo-$'

    37

        >>> parse_generate_field("\$")(1)

    38

        '$'

    39

        >>> parse_generate_field("10.0.0.${100}")(1)

    40

        '10.0.0.101'

    41

        >>> parse_generate_field("foo-${0,2,d}")(1)

    42

        'foo-01'

    43

    44

    """

    45

    46

    input = field

    47

    expr = []

    48

    49

    while '$' in field :

    50

        # defaults

    51

        offset = 0

    52

        width = 0

    53

        base = 'd'

    54

        escape = False

    55

    56

        # different forms

    57

        if '${' in field :

    58

            pre, body = field.split('${', 1)

    59

            body, post = body.split('}', 1)

    60

    61

            # parse body

    62

            parts = body.split(',')

    63

    64

            # offset

    65

            offset = int(parts.pop(0))

    66

    67

            # width

    68

            if parts :

    69

                width = int(parts.pop(0))

    70

    71

            # base

    72

            if parts :

    73

                base = parts.pop(0)

    74

    75

            if parts:

    76

                # fail

    77

                raise ValueError("extra data in ${...} body: {0!r}", parts)

    78

    79

        elif '$$' in field :

    80

            pre, post = field.split('$$', 1)

    81

            escape = True

    82

    83

        elif '\\$' in field :

    84

            pre, post = field.split('\\$', 1)

    85

            escape = True

    86

    87

        else :

    88

            pre, post = field.split('$', 1)

    89

    90

        expr.append(pre)

    91

    92

        if escape :

    93

            expr.append('$')

    94

    95

        else :

    96

            # meta-format

    97

            fmt = '{value[%d]:0%d%s}' % (offset, width, base)

    98

    99

            log.debug("field=%r -> pre=%r, fmt=%r, post=%r", field, expr, fmt, post)

   100

   101

            expr.append(fmt)

   102

   103

        field = post

   104

   105

    # final

   106

    if field :

   107

        expr.append(field)

   108

   109

    # combine

   110

    expr = ''.join(expr)

   111

   112

    log.debug("%s: %s", input, expr)

   113

   114

    # processed

   115

    def value_func (value) :

   116

        # magic wrapper to implement offsets

   117

        return expr.format(value=OffsetValue(value))

   118

   119

    return value_func

   120

   121

def parse_generate_range (field) :

   122

    """

   123

        Parse a <start>-<stop>[/<step>] field

   124

    """

   125

   126

    if '/' in field :

   127

        field, step = field.split('/')

   128

        step = int(step)

   129

    else :

   130

        step = 1

   131

   132

    start, stop = field.split('-')

   133

    start = int(start)

   134

    stop = int(stop)

   135

   136

    log.debug("  range: start=%r, stop=%r, step=%r", start, stop, step)

   137

   138

    # inclusive

   139

    return range(start, stop + 1, step)

   140