1

"""

     2

    DHCP dhcpd.leases handling/tracking

     3

"""

     4

     5

import pvl.syslog.tail # TailFile

     6

     7

from datetime import datetime

     8

     9

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

    10

    13

class DHCPLeasesParser (object) :

    14

    """

    15

        Simplistic parser for a dhcpd.leases file.

    16

    17

        Doesn't implement the full spec, but a useful approximation.

    18

    """

    19

    20

    def __init__ (self) :

    21

        self.block = None

    22

        self.items = []

    23

    24

    @classmethod

    25

    def split (cls, line) :

    26

        """

    27

            Split given line-data.

    28

    29

            >>> split = DHCPLeasesParser.split

    30

            >>> split('foo bar')

    31

            ['foo', 'bar']

    32

            >>> split('"foo"')

    33

            ['foo']

    34

            >>> split('foo "asdf quux" bar')

    35

            ['foo', 'asdf quux', 'bar']

    36

            >>> split('foo "asdf quux"')

    37

            ['foo', 'asdf quux']

    38

        """

    39

    40

        # parse out one str

    41

        if '"' in line :

    42

            log.debug("%s", line)

    43

    44

            # crude

    45

            pre, line = line.split('"', 1)

    46

            data, post = line.rsplit('"', 1)

    47

    48

            return pre.split() + [data] + post.split()

    49

        else :

    50

            return line.split()

    51

    52

    @classmethod

    53

    def lex (self, line) :

    54

        """

    55

            Yield tokens from the given lines.

    56

    57

            >>> lex = DHCPLeasesParser.lex

    58

            >>> list(lex('foo;'))

    59

            [('item', ['foo'])]

    60

            >>> list(item for line in ['foo {', ' bar;', '}'] for item in lex(line))

    61

            [('open', ['foo']), ('item', ['bar']), ('close', None)]

    62

    63

        """

    64

    65

        log.debug("%s", line)

    66

    67

        # comments?

    68

        if '#' in line :

    69

            line, comment = line.split('#', 1)

    70

        else :

    71

            comment = None

    72

    73

        # clean?

    74

        line = line.strip()

    75

    76

        # parse

    77

        if not line :

    78

            # ignore, empty/comment

    79

            return

    80

    81

        elif line.startswith('uid') :

    82

            # XXX: too hard to parse properly

    83

            return

    84

    85

        elif '{' in line :

    86

            decl, line = line.split('{', 1)

    87

    88

            # we are in a new decl

    89

            yield 'open', self.split(decl)

    90

    91

        elif ';' in line :

    92

            param, line = line.split(';', 1)

    93

    94

            # a stanza

    95

            yield 'item', self.split(param)

    96

    97

        elif '}' in line :

    98

            close, line = line.split('}', 1)

    99

   100

            if close.strip() :

   101

                log.warn("Predata on close: %s", close)

   102

   103

            # end

   104

            yield 'close', None

   105

   106

        else :

   107

            log.warn("Unknown line: %s", line)

   108

            return

   109

   110

        # got the whole line?

   111

        if line.strip() :

   112

            log.warn("Data remains: %s", line)

   113

   114

    def push_block (self, block) :

   115

        """

   116

            Open new block.

   117

        """

   118

   119

        # XXX: stack

   120

        assert not self.block

   121

   122

        self.block = block

   123

        self.items = []

   124

   125

    def feed_block (self, item) :

   126

        """

   127

            Add item to block

   128

        """

   129

   130

        assert self.block

   131

   132

        self.items.append(item)

   133

   134

    def pop_block (self) :

   135

        """

   136

            Close block. Returns

   137

                (block, [items])

   138

        """

   139

   140

        assert self.block

   141

   142

        block, items = self.block, self.items

   143

   144

        self.block = None

   145

        self.items = None

   146

   147

        return block, items

   148

   149

    def parse (self, line) :

   150

        """

   151

            Parse given line, yielding any complete blocks that come out.

   152

   153

            >>> parser = DHCPLeasesParser()

   154

            >>> list(parser.parse_lines(['foo {', ' bar;', ' quux asdf;', '}']))

   155

            [(['foo'], [['bar'], ['quux', 'asdf']])]

   156

   157

            >>> parser = DHCPLeasesParser()

   158

            >>> list(parser.parse('foo {'))

   159

            []

   160

            >>> list(parser.parse_lines([' bar;', ' quux asdf;']))

   161

            []

   162

            >>> list(parser.parse('}'))

   163

            [(['foo'], [['bar'], ['quux', 'asdf']])]

   164

        """

   165

   166

        for token, args in self.lex(line) :

   167

            #log.debug("%s: %s [block=%s]", token, args, self.block)

   168

   169

            if token == 'open' :

   170

                # open new block

   171

                block = args

   172

   173

                if self.block :

   174

                    log.warn("nested blocks: %s > %s", self.block, block)

   175

                    continue

   176

   177

                log.debug("open block: %s", block)

   178

                self.push_block(block)

   179

   180

            elif token == 'close' :

   181

                log.debug("close block: %s", self.block)

   182

   183

                # collected block items

   184

                yield self.pop_block()

   185

   186

            # must be within block!

   187

            elif token == 'item' :

   188

                item = args

   189

   190

                if not self.block :

   191

                    log.warn("token outside block: %s: %s", token, args)

   192

                    continue

   193

   194

                log.debug("block %s item: %s", self.block, item)

   195

                self.feed_block(item)

   196

   197

            else :

   198

                # ???

   199

                raise KeyError("Unknown token: {0}: {1}".format(token, args))

   200

   201

    def parse_lines (self, lines) :

   202

        """

   203

            Trivial wrapper around parse to parse multiple lines.

   204

        """

   205

   206

        for line in lines :

   207

            for item in self.parse(line) :

   208

                yield item

   209

   210

class DHCPLeases (object) :

   211

    """

   212

        Process log-structured leases file, updated by dhcpd.

   213

    """

   214

   215

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

   216

   217

    # default format

   218

    LEASE_DATE_NEVER = 'never'

   219

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

   220

   221

    lease_date_fmt = LEASE_DATE_FMT_DEFAULT

   222

   224

        """

   225

            path        - path to dhcpd.leases file

   226

        """

   227

   228

        # tail; handles file re-writes

   229

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

   230

   231

        # parser state

   232

        self.parser = DHCPLeasesParser()

   233

   234

        # initial leases state

   235

        self._leases = None

   236

   237

    def reset (self) :

   238

        """

   239

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

   240

        """

   241

   242

        self._leases = {}

   243

   244

    def process_lease_item_date (self, args) :

   245

        """

   246

            Process lease-item date spec into datetime.

   247

   248

            Returns None if 'never'.

   249

        """

   250

   251

        data = ' '.join(args)

   252

   253

        if data == self.LEASE_DATE_NEVER :

   254

            return None

   255

        else :

   256

            return datetime.strptime(data, self.lease_date_fmt)

   257

   258

    def process_lease_item (self, lease, item) :

   259

        """

   260

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

   261

        """

   262

   263

        item = list(item)

   264

   265

        name = item.pop(0)

   266

        subname = item[0] if item else None

   267

   268

        if name in self.LEASE_DATES :

   269

            lease[name] = self.process_lease_item_date(item)

   270

   271

        elif name == 'hardware':

   272

            # args

   273

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

   274

   275

        elif name == 'uid' :

   276

            lease['uid'], = item

   277

   278

        elif name == 'client-hostname' :

   279

            lease['client-hostname'], = item

   280

   281

        elif name == 'abandoned' :

   282

            lease['abandoned'] = True

   283

   284

        elif name == 'binding' :

   285

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

   286

   287

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

   288

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

   289

   290

        else :

   291

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

   292

   293

    def process_lease (self, lease_name, items) :

   294

        """

   295

            Process given lease block to update our state.

   296

   297

            Returns the lease object, and a possible old lease.

   298

        """

   299

   300

        # replace any existing

   301

        lease = self._leases[lease_name] = {}

   302

   303

        # meta

   304

        lease['lease'] = lease_name

   305

   306

        # parse items

   307

        for item in items :

   308

            try :

   309

                self.process_lease_item(lease, item)

   310

   311

            except Exception as ex:

   312

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

   313

   314

        # k

   315

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

   316

   317

        return lease

   318

   319

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

   320

        """

   321

            Log given lease transition on stdout.

   322

        """

   323

   324

        # log

   325

        if old_lease :

   326

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

   327

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

   328

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

   329

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

   330

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

   331

            )

   332

   333

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

   334

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

   335

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

   336

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

   337

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

   338

        )

   339

   340

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

   341

        """

   342

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

   343

        """

   344

   345

        block, items = blockdata

   346

   347

        type = block.pop(0)

   348

        args = block

   349

   350

        if type == 'lease' :

   351

            if len(args) != 1 :

   352

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

   353

   354

            # the lease address

   355

            lease, = args

   356

   357

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

   358

   359

            if lease in self._leases :

   360

                old = self._leases[lease]

   361

            else :

   362

                old = None

   363

   364

            new = self.process_lease(lease, items)

   365

   366

            if log_leases :

   367

                self.log_lease(new, old)

   368

   369

            return new

   370

   371

        else :

   372

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

   373

   374

    def readleases (self) :

   375

        """

   376

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

   377

   378

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

   379

        """

   380

   381

        # handle file replace by reading until EOF

   382

        sync = False

   383

#        leases = []

   384

   385

        if self._leases is None :

   386

            # initial sync

   387

            self.reset()

   388

            sync = True

   389

   390

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

   391

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

   392

            if line is None :

   393

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

   394

   395

                # resync

   396

                self.reset()

   397

                sync = True

   398

   399

            else :

   400

                # parse

   401

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

   402

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

   403

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

   404

   405

                    #if not sync :

   406

                    #    leases.append(lease)

   407

                    yield lease

   408

   409

#        if sync :

   410

#            return True, self.leases.values()

   411

#        else :

   412

#            return False, leases

   413

   414

    __iter__ = readleases

   415

   416

    def leases (self) :

   417

        """

   418

            Iterate over all leases.

   419

        """

   420

   422

   423

    # utils

   424

    def lease_state (self, lease) :

   425

        """

   426

            Get state for lease.

   427

        """

   428

   429

        # count by state

   430

        starts = lease.get('starts')

   431

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

   432

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

   433

        ends = lease.get('ends')

   434

   435

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

   436

   437

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

   438

            # XXX: mark as, "expired", even they next-binding-state is probably "free"

   439

            state = 'expired' # lease['next-binding-state']

   440

   441

        return state

   442

   443

# XXX: from db.dhcp_leases instead?

   444

import pvl.verkko.db as db

   445

   446

class DHCPLeasesDatabase (object) :

   447

    """

   448

        pvl.verkko.Database dhcp_leases model for updates.

   449

    """

   450

   451

    def __init__ (self, db) :

   452

        """

   453

            db      - pvl.verkko.Database

   454

        """

   455

   456

        self.db = db

   457

   458

    def create (self) :

   459

        """

   460

            CREATE TABLEs

   461

        """

   462

   463

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

   464

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

   465

   466

    def update (self, lease) :

   467

        """

   468

            Try an extend an existing lease?

   469

        """

   470

   471

        c = db.dhcp_leases.c

   472

   473

        ip = lease['lease']

   474

        mac = lease.get('hwaddr')

   475

        starts = lease['starts']

   476

        ends = lease.get('ends')

   477

   478

        update = db.dhcp_leases.update()

   479

   480

        # XXX: if ends is None?

   481

        if mac :

   482

            # renew lease..?

   483

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

   484

        else :

   485

            # new state for lease..?

   486

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

   487

   488

        update = update.values(

   489

                state       = lease['binding-state'],

   490

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

   491

                ends        = ends,

   492

        )

   493

   494

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

   495

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

   496

   497

        return self.db.update(update) > 0

   498

   499

    def insert (self, lease) :

   500

        """

   501

            Record a new lease.

   502

        """

   503

   504

        c = db.dhcp_leases.c

   505

   506

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

   507

            ip          = lease['lease'],

   508

            mac         = lease['hwaddr'],

   509

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

   510

   511

            starts      = lease['starts'],

   512

            ends        = lease.get('ends'),

   513

   514

            state       = lease['binding-state'],

   515

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

   516

        )

   517

   518

        return self.db.insert(query)

   519

   520

    def __call__ (self, lease) :

   521

        """