1

"""

     2

    DHCP... stuff

     3

"""

     4

     5

import re

     6

import functools

     7

from datetime import datetime, timedelta

     8

     9

TIMEDELTA_RE = re.compile(r'(\d+)([a-z]*)', re.IGNORECASE)

    10

TIMEDELTA_UNITS = {

    11

    'd':    'days',

    12

    'h':    'hours',

    13

    'm':    'minutes',

    14

    's':    'seconds',

    15

}

    16

    17

def parse_timedelta (expr) :

    18

    """

    19

        Parse timeout -> timedelta

    20

    21

        >>> parse_timedelta('1d')

    22

        datetime.timedelta(1)

    23

        >>> parse_timedelta('1h')

    24

        datetime.timedelta(0, 3600)

    25

        >>> parse_timedelta('15m')

    26

        datetime.timedelta(0, 900)

    27

        >>> parse_timedelta('1d1h1s')

    28

        datetime.timedelta(1, 3601)

    29

    """

    30

    31

    what = {}

    32

    33

    for (value, unit) in TIMEDELTA_RE.findall(expr) :

    34

        unit = unit.lower()

    35

        value = int(value)

    36

    37

        if unit in TIMEDELTA_UNITS :

    38

            what[TIMEDELTA_UNITS[unit]] = value

    39

        else :

    40

            raise ValueError(unit)

    41

    42

    return timedelta(**what)

    43

    44

def format_timedelta (td):

    45

    """

    46

        datetime.timedelta -> str

    47

    48

        >>> print timedelta_str(timedelta(days=1))

    49

        1d

    50

        >>> print timedelta_str(timedelta(hours=6))

    51

        6h

    52

        >>> print timedelta_str(timedelta(days=2, hours=6, seconds=120))

    53

        2d6h2m

    54

    """

    55

    56

    # divmod

    57

    days = td.days

    58

    59

    seconds = td.seconds

    60

    minutes, seconds = divmod(seconds, 60)

    61

    hours, minutes = divmod(minutes, 60)

    62

    63

    # format

    64

    data = (

    65

        (days,      'd'),

    66

        (hours,     'h'),

    67

        (minutes,   'm'),

    68

        (seconds,   's'),

    69

    )

    70

    71

    return ''.join('%d%s' % (count, unit) for count, unit in data if count)

    72

    73

def parse_addr (addr, pad=False) :

    74

    """

    75

        Parse IPv4 addr -> int.

    76

    77

            partial     - allow partial addrs; right-pad with .0

    78

    79

        >>> print "%#010x/%d" % parse_addr('1.2.3.4')

    80

        0x01020304/32

    81

        >>> print "%#010x/%d" % parse_addr('1.2', pad=True)

    82

        0x01020000/16

    83

    84

    """

    85

    86

    # split net

    87

    addr = [int(part) for part in addr.split('.') if part]

    88

    89

    addrlen = len(addr) * 8

    90

    91

    # fixup base?

    92

    if len(addr) == 4 :

    93

        # fine

    94

        pass

    95

    96

    elif len(addr) > 4 :

    97

        raise ValueError("Invalid IPv4 net: {0}".format(addr))

    98

    99

    elif len(addr) < 4 and pad :

   100

        # pad

   101

        addr += [0] * (4 - len(addr))

   102

   103

    else :

   104

        raise ValueError("Incomplete IPv4 addr: {0}".format(addr))

   105

   106

    # pack to int

   107

    return functools.reduce(lambda a, b: a * 256 + b, addr), addrlen

   108

   109

def parse_net (expr) :

   110

    """

   111

        Parse given expr into (base, mask).

   112

   113

        >>> print "%#010x/%#010x" % parse_net('1.2.3.4')

   114

        0x01020304/0xffffffff

   115

        >>> print "%#010x/%#010x" % parse_net('1.2.0.0/16')

   116

        0x01020000/0xffff0000

   117

        >>> print "%#010x/%#010x" % parse_net('1.2')

   118

        0x01020000/0xffff0000

   119

    """

   120

   121

    if '/' in expr :

   122

        net, masklen = expr.split('/', 1)

   123

   124

        masklen = int(masklen)

   125

   126

    else :

   127

        net = expr

   128

        masklen = None

   129

   130

    base, baselen = parse_addr(net, pad=True)

   131

   132

    if not masklen :

   133

        # implicit mask, by leaving off octets in the base

   134

        masklen = baselen

   135

   136

    elif masklen > 32 :

   137

        raise ValueError("Invalid IPv4 mask: /{0:d}".format(masklen))

   138

   139

    # pack

   140

    mask = (0xffffffff << (32 - masklen)) & 0xffffffff

   141

   142

    # verify

   143

    if base & ~mask :

   144

        raise ValueError("Invalid IPv4 net base: {base:x} & {mask:x}".format(base=base, mask=mask))

   145

   146

    return base, mask, masklen

   147

   148

def IPv4Address (addr) :

   149

    """

   150

        Parse IPv4 address to int.

   151

    """

   152

   153

    addr, len = parse_addr(addr)

   154

   155

    return addr

   156

   157

class IPv4Network (object) :

   158

    """

   159

        Parse and match network masks.

   160

   161

        XXX: is used as a dict key

   162

    """

   163

   164

    def __init__ (self, expr) :

   165

        self.expr = expr

   166

        self.base, self.mask, self.masklen = parse_net(expr)

   167

   168

    def __contains__ (self, addr) :

   169

        return (addr & self.mask) == self.base

   170

   171

    def __str__ (self) :

   172

        return self.expr

   173

   174

    def __repr__ (self) :

   175

        return "IPv4Network(%r)" % (self.expr, )

   176

   177

if __name__ == '__main__' :

   178

    import logging

   179

   180

    logging.basicConfig()

   181

   182

    import doctest

   183

    doctest.testmod()

   184