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',             metavar='NET', action='append',

    28

            help="dhcp plugin instance by network")

    29

    30

    parser.add_option('--dhcp-gateway',             metavar='NET', action='append',

    31

            help="dhcp plugin instance by gateway")

    32

    33

    return parser

    34

    35

def apply_rules (options) :

    36

    """

    37

        Yield DHCPRules from options.

    38

    """

    39

    40

    for gateway in options.dhcp_gateway :

    41

        yield DHCPRule.rule(gateway, gateway=gateway)

    42

    43

    for network in options.dhcp_network :

    44

        yield DHCPRule.rule(network, network=network)

    45

    46

    if options.dhcp_rules :

    47

        yield DHCPRule.load(open(options.dhcp_rules))

    48

    49

def apply (options) :

    50

    """

    51

        Return DHCPRule from options.

    52

    """

    53

    54

    return DHCPRule(None, tuple(apply_rules(options)))

    55

    56

class DHCPRule (object) :

    57

    """

    58

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

    59

    60

        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.

    61

    """

    62

    63

    64

    @classmethod

    65

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

    66

        """

    67

            Load from config file.

    68

        """

    69

    70

        config = configobj.ConfigObj(file)

    71

    72

        return cls.load_section(name, config)

    73

    74

    @classmethod

    75

    def load_section (cls, name, section) :

    76

        """

    77

            Rule from sub-sections and section.

    78

        """

    79

    80

        # recurse

    81

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

    82

    83

        # rule

    84

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

    85

    86

        try :

    87

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

    88

    89

        except ValueError as ex :

    90

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

    91

    92

    @classmethod

    93

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

    94

        """

    95

            Rule from section.

    96

        """

    97

    98

        if interval :

    99

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

   100

   101

        if network :

   102

            network = IPv4Network(network)

   103

        else :

   104

            network = None

   105

   106

        return cls(name, rules,

   107

                gateway     = gateway, 

   108

                network     = network,

   109

        )

   110

   111

    @classmethod

   112

    def rule (cls, name, gateway=None, network=None) :

   113

        if network :

   114

            network = IPv4Network(network)

   115

        else :

   116

            network = None

   117

   118

        return cls(name, (),

   119

                gateway     = gateway, 

   120

                network     = network,

   121

        )

   122

   123

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

   124

        """

   125

            Match as name by gateway/network.

   126

        """

   127

   128

        self.name = name

   129

        self.rules = rules

   130

   131

        self.gateway = gateway

   132

        self.network = network

   133

   134

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

   135

   136

    def match (self, host) :

   137

        """

   138

            Match against given host.

   139

        """

   140

   141

        if self.gateway :

   142

            gateway = host.get('gw')

   143

   144

            if gateway and gateway != self.gateway :

   145

                gateway = False

   146

   147

        else :

   148

            gateway = None

   149

   150

        if self.network :

   151

            network = host.get('ip')

   152

   153

            if network and network != self.network :

   154

                network = False

   155

        else :

   156

            network = None

   157

   158

        # decide

   159

        if network is False or gateway is False :

   160

            # negative

   161

            return False

   162

   163

        elif network or gateway :

   164

            # (partial) positive

   165

            return True

   166

   167

        else :

   168

            # unknown

   169

            return None

   170

   171

    def apply (self, host) :

   172

        """

   173

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

   174

        """

   175

   176

        match = self.match(host)

   177

   178

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

   179

   180

        if match is False :

   181

            # negative

   182

            return

   183

   184

        for rule in self.rules :

   185

            apply = rule.apply(host)

   186

   187

            if apply :

   188

                return apply

   189

   190

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

   191

   192

        if match :

   193

            # positive

   194

            return self

   195

        else :

   196

            # unknown

   197

            return None

   198

   199

    def __str__ (self) :

   200

        return self.name or ''

   201

   202