1

"""

     2

    Match DHCP clients by network.

     3

"""

     4

     5

import optparse

     6

import configobj

     7

     8

from pvl.verkko.utils import IPv4Address, IPv4Network

     9

    10

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

    11

    12

def parser (parser) :

    13

    """

    14

        Optparse options for DHCPRule

    15

    """

    16

    17

    parser.set_defaults(

    18

            dhcp_network        = [],

    19

            dhcp_gateway        = [],

    20

    )

    21

    22

    parser = optparse.OptionGroup(parser, "DHCP host/lease matching")

    23

    24

    parser.add_option('--dhcp-rules',               metavar='CONF',

    25

            help="dhcp plugin instances by network/gateway")

    26

    27

    parser.add_option('--dhcp-network',             action='store_true',

    28

            help="dhcp plugin instance by network")

    29

    30

    parser.add_option('--dhcp-gateway',             action='store_true',

    31

            help="dhcp plugin instance by gateway")

    32

    33

    return parser

    34

    35

def apply (options) :

    36

    """

    37

        Return DHCPRule from options.

    38

    """

    39

    40

    if options.dhcp_rules :

    41

        return DHCPRule.load(options, open(options.dhcp_rules))

    42

    else :

    43

        return DHCPRule()

    44

    45

class DHCPRule (object) :

    46

    """

    47

        A rule matching DHCP hosts/leases by gateway/network.

    48

    49

        Note that leases don't have a gateway, but they're assumed to be valid, so we just ignore any gateway criteria for for unknown gateways.

    50

    """

    51

    52

    53

    @classmethod

    54

    def load (cls, options, file, name=None) :

    55

        """

    56

            Load from config file.

    57

        """

    58

    59

        config = configobj.ConfigObj(file)

    60

    61

        return cls.load_section(options, name, config)

    62

    63

    @classmethod

    64

    def load_section (cls, options, name, section) :

    65

        """

    66

            Rule from sub-sections and section.

    67

        """

    68

    69

        # recurse

    70

        rules = tuple(cls.load_section(options, subsection, section[subsection]) for subsection in section.sections)

    71

    72

        # rule

    73

        attrs = dict((name, section[name]) for name in section.scalars)

    74

    75

        try :

    76

            return cls.config(options, name, rules, **attrs)

    77

    78

        except ValueError as ex :

    79

            raise ValueError("[%s] %s" % (name, ex))

    80

    81

    @classmethod

    82

    def config (cls, options, name, rules, gateway=None, network=None, interval=None) :

    83

        """

    84

            Rule from section.

    85

        """

    86

    87

        if interval :

    88

            log.warn("%s: interval: not implemented", name)

    89

    90

        if network and options.dhcp_network :

    91

            network = IPv4Network(network)

    92

        else :

    93

            network = None

    94

    95

        if gateway and options.dhcp_gateway :

    96

            gateway = gateway

    97

        else :

    98

            gateway = None

    99

   100

        return cls(name, rules,

   101

                gateway     = gateway, 

   102

                network     = network,

   103

        )

   104

   105

    def __init__ (self, name=None, rules=(), gateway=None, network=None) :

   106

        """

   107

            Match as name by gateway/network.

   108

        """

   109

   110

        self.name = name

   111

        self.rules = rules

   112

   113

        self.gateway = gateway

   114

        self.network = network

   115

   116

        log.info("%s: gateway=%s, network=%s: %s", name, gateway, network, ' '.join(str(rule) for rule in rules))

   117

   118

    def match (self, host) :

   119

        """

   120

            Match against given host.

   121

        """

   122

   123

        if self.gateway :

   124

            gateway = host.get('gw')

   125

   126

            if gateway and gateway != self.gateway :

   127

                gateway = False

   128

   129

        else :

   130

            gateway = None

   131

   132

        if self.network :

   133

            network = host.get('ip')

   134

   135

            if network and network not in self.network :

   136

                network = False

   137

        else :

   138

            network = None

   139

   140

        # decide

   141

        if network is False or gateway is False :

   142

            # negative

   143

            return False

   144

   145

        elif network or gateway :

   146

            # (partial) positive

   147

            return True

   148

   149

        else :

   150

            # unknown

   151

            return None

   152

   153

    def apply (self, host) :

   154

        """

   155

            Match { gw: str, ip: IPv4Address } against our rule and any sub rules, returning matching DHCPHostRule, or None.

   156

        """

   157

   158

        match = self.match(host)

   159

   160

        log.debug("%s: match: %s: %s", self, host, match)

   161

   162

        if match is False :

   163

            # negative

   164

            return

   165

   166

        for rule in self.rules :

   167

            apply = rule.apply(host)

   168

   169

            if apply :

   170

                return apply

   171

   172

        log.debug("%s: apply: %s", self, host)

   173

   174

        if match :

   175

            # positive

   176

            return self

   177

        else :

   178

            # unknown

   179

            return None

   180

   181

    def __str__ (self) :

   182

        return self.name or ''

   183

   184