1

"""

     2

    DHCP dhcpd.leases handling/tracking

     3

"""

     4

     5

import pvl.syslog.tail # TailFile

     6

     7

from datetime import datetime

     8

from pvl.dhcp.config import DHCPConfigParser

     9

    10

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

    11

    12

DHCPD_LEASES = '/var/lib/dhcp/dhcpd.leases'

    13

    14

class DHCPLeases (object) :

    15

    """

    16

        Process log-structured leases file, updated by dhcpd.

    17

    """

    18

    19

    LEASE_DATES = ('starts', 'ends', 'tstp', 'tsfp', 'atsfp', 'cltt')

    20

    21

    # default format

    22

    LEASE_DATE_NEVER = 'never'

    23

    LEASE_DATE_FMT_DEFAULT = '%w %Y/%m/%d %H:%M:%S'

    24

    25

    lease_date_fmt = LEASE_DATE_FMT_DEFAULT

    26

    27

    def __init__ (self, path=DHCPD_LEASES) :

    28

        """

    29

            path        - path to dhcpd.leases file

    30

        """

    31

    32

        # tail; handles file re-writes

    33

        self.source = pvl.syslog.tail.Tail(path)

    34

    35

        # parser state

    36

        self.parser = DHCPConfigParser()

    37

    38

        # initial leases state

    39

        self._leases = None

    40

    41

    def reset (self) :

    42

        """

    43

            Reset state, if we started to read a new file.

    44

        """

    45

    46

        self._leases = {}

    47

    48

    def process_lease_item_date (self, args) :

    49

        """

    50

            Process lease-item date spec into datetime.

    51

    52

            Returns None if 'never'.

    53

        """

    54

    55

        data = ' '.join(args)

    56

    57

        if data == self.LEASE_DATE_NEVER :

    58

            return None

    59

        else :

    60

            return datetime.strptime(data, self.lease_date_fmt)

    61

    62

    def process_lease_item (self, lease, item) :

    63

        """

    64

            Process a single item from the lease, updating the lease dict

    65

        """

    66

    67

        item = list(item)

    68

    69

        name = item.pop(0)

    70

        subname = item[0] if item else None

    71

    72

        if name in self.LEASE_DATES :

    73

            lease[name] = self.process_lease_item_date(item)

    74

    75

        elif name == 'hardware':

    76

            # args

    77

            lease['hwtype'], lease['hwaddr'] = item

    78

    79

        elif name == 'uid' :

    80

            lease['uid'], = item

    81

    82

        elif name == 'client-hostname' :

    83

            lease['client-hostname'], = item

    84

    85

        elif name == 'abandoned' :

    86

            lease['abandoned'] = True

    87

    88

        elif name == 'binding' :

    89

            _state, lease['binding-state'] = item

    90

    91

        elif name == 'next' and subname == 'binding' :

    92

            _binding, _state, lease['next-binding-state'] = item

    93

    94

        else :

    95

            log.warn("unknown lease item: %s: %s", name, item)

    96

    97

    def process_lease (self, lease_name, items) :

    98

        """

    99

            Process given lease block to update our state.

   100

   101

            Returns the lease object, and a possible old lease.

   102

        """

   103

   104

        # replace any existing

   105

        lease = self._leases[lease_name] = {}

   106

   107

        # meta

   108

        lease['lease'] = lease_name

   109

   110

        # parse items

   111

        for item in items :

   112

            try :

   113

                self.process_lease_item(lease, item)

   114

   115

            except Exception as ex:

   116

                log.warn("Failed to process lease item: %s: %s:", lease_name, item, exc_info=True)

   117

   118

        # k

   119

        log.debug("%-15s: %s", lease_name, lease)

   120

   121

        return lease

   122

   123

    def log_lease (self, lease, old_lease=None) :

   124

        """

   125

            Log given lease transition on stdout.

   126

        """

   127

   128

        # log

   129

        if old_lease :

   130

            log.info("%-15s: %20s @ %8s <- %-8s @ %20s", old_lease['lease'],

   131

                old_lease.get('ends', '???'),

   132

                old_lease.get('next-binding-state', ''),    # optional

   133

                old_lease.get('binding-state', '???'), 

   134

                old_lease.get('starts', '???'),

   135

            )

   136

   137

        log.info("%-15s: %20s @ %8s -> %-8s @ %20s", lease['lease'], 

   138

                lease.get('starts', '???'),

   139

                lease.get('binding-state', '???'), 

   140

                lease.get('next-binding-state', ''),    # optional

   141

                lease.get('ends', '???'),

   142

        )

   143

   144

    def process_block (self, blockdata, log_leases=False) :

   145

        """

   146

            Process given block (from DHCPConfigParser.parse()), to update state.

   147

        """

   148

   149

        block, items = blockdata

   150

   151

        type = block.pop(0)

   152

        args = block

   153

   154

        if type == 'lease' :

   155

            if len(args) != 1 :

   156

                return log.warn("lease block with weird args, ignore: %s", args)

   157

   158

            # the lease address

   159

            lease, = args

   160

   161

            log.debug("lease: %s: %s", lease, items)

   162

   163

            if lease in self._leases :

   164

                old = self._leases[lease]

   165

            else :

   166

                old = None

   167

   168

            new = self.process_lease(lease, items)

   169

   170

            if log_leases :

   171

                self.log_lease(new, old)

   172

   173

            return new

   174

   175

        else :

   176

            log.warn("unknown block: %s: %s", type, args)

   177

   178

    def readleases (self) :

   179

        """

   180

            Read new lines from the leases database and update our state.

   181

   182

            Yields changed leases. On startup and on periodic database reset, all leases are yielded.

   183

        """

   184

   185

        # handle file replace by reading until EOF

   186

        sync = False

   187

#        leases = []

   188

   189

        if self._leases is None :

   190

            # initial sync

   191

            self.reset()

   192

            sync = True

   193

   194

        # parse in any new lines from TailFile... yields None if the file was replaced

   195

        for line in self.source.readlines(eof_mark=True) :

   196

            if line is None :

   197

                log.info("Reading new dhcpd.leases")

   198

   199

                # resync

   200

                self.reset()

   201

                sync = True

   202

   203

            else :

   204

                # parse

   205

                for blockdata in self.parser.parse_line(line) :

   206

                    # don't log if syncing, only on normal updates (next tail-cycle)

   207

                    lease = self.process_block(blockdata, log_leases=(not sync))

   208

   209

                    #if not sync :

   210

                    #    leases.append(lease)

   211

                    yield lease

   212

   213

#        if sync :

   214

#            return True, self.leases.values()

   215

#        else :

   216

#            return False, leases

   217

   218

    __iter__ = readleases

   219

   220

    def leases (self) :

   221

        """

   222

            Iterate over all leases.

   223

        """

   224

   225

        return self._leases.itervalues()

   226

   227

    # utils

   228

    def lease_state (self, lease) :

   229

        """

   230

            Get state for lease.

   231

        """

   232

   233

        # count by state

   234

        starts = lease.get('starts')

   235

        state = lease.get('binding-state')

   236

        next_state = lease.get('next-binding-state')

   237

        ends = lease.get('ends')

   238

   239

        #log.debug("%-15s: %s: %8s -> %-8s: %s", ip, starts, state, next_state or '', ends)

   240

   241

        # XXX: datetime UTC or local?

   242

        if next_state and ends and ends < datetime.now() :

   243

            state = next_state

   244

   245

        return state

   246

   247

# XXX: from db.dhcp_leases instead?

   248

import pvl.verkko.db as db

   249

   250

class DHCPLeasesDatabase (object) :

   251

    """

   252

        pvl.verkko.Database dhcp_leases model for updates.

   253

    """

   254

   255

    def __init__ (self, db) :

   256

        """

   257

            db      - pvl.verkko.Database

   258

        """

   259

   260

        self.db = db

   261

   262

    def create (self) :

   263

        """

   264

            CREATE TABLEs

   265

        """

   266

   267

        log.info("Creating database tables: dhcp_leases")

   268

        db.dhcp_leases.create(self.db.engine, checkfirst=True)

   269

   270

    def update (self, lease) :

   271

        """

   272

            Try an extend an existing lease?

   273

        """

   274

   275

        c = db.dhcp_leases.c

   276

   277

        ip = lease['lease']

   278

        mac = lease.get('hwaddr')

   279

        starts = lease['starts']

   280

        ends = lease.get('ends')

   281

   282

        update = db.dhcp_leases.update()

   283

   284

        # XXX: if ends is None?

   285

        if mac :

   286

            # renew lease..?

   287

            update = update.where((c.ip == ip) & (c.mac == mac) & ((starts < c.ends) | (c.ends == None)))

   288

        else :

   289

            # new state for lease..?

   290

            update = update.where((c.ip == ip) & ((starts < c.ends) | (c.ends == ends)))

   291

   292

        update = update.values(

   293

                state       = lease['binding-state'],

   294

                next        = lease.get('next-binding-state'),

   295

                ends        = ends,

   296

        )

   297

   298

        if lease.get('client-hostname') :

   299

            update = update.values(hostname = lease['client-hostname'])

   300

   301

        return self.db.update(update) > 0

   302

   303

    def insert (self, lease) :

   304

        """

   305

            Record a new lease.

   306

        """

   307

   308

        c = db.dhcp_leases.c

   309

   310

        query = db.dhcp_leases.insert().values(

   311

            ip          = lease['lease'],

   312

            mac         = lease['hwaddr'],

   313

            hostname    = lease.get('client-hostname'),

   314

   315

            starts      = lease['starts'],

   316

            ends        = lease.get('ends'),

   317

   318

            state       = lease['binding-state'],

   319

            next        = lease.get('next-binding-state'),

   320

        )

   321

   322

        return self.db.insert(query)

   323

   324

    def __call__ (self, lease) :

   325

        """

   326

            Process given DHCP lease to update currently active lease, or insert a new one.

   327

   328

            XXX: transaction? *leases?

   329

        """

   330

   331

        # update existing?

   332

        if self.update(lease) :

   333

            log.info("Update: %s", lease)

   334

   335

        elif lease.get('hwaddr') :

   336

            # new

   337

            id = self.insert(lease)

   338

   339

            log.info("Insert: %s -> %d", lease, id)

   340

   341

        else :

   342

            # may be a free lease

   343

            log.warn("Ignored lease: %s", lease)

   344

   345

   346

if __name__ == '__main__' :

   347

    import logging

   348

   349

    logging.basicConfig()

   350

   351

    import doctest

   352

    doctest.testmod()

   353