1

from pvl.verkko import web, db, table

     2

from pvl.verkko.utils import parse_timedelta, format_timedelta

     3

     4

from pvl.web import html

     5

     6

import datetime

     7

     8

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

     9

    10

class DHCPLease (object) :

    11

    """

    12

        A DHCP lease with ip/mac and starts/ends

    13

    """

    14

    15

    DATE_FMT = '%Y%m%d %H:%M'

    16

    TIME_FMT = '%H:%M:%S'

    17

    18

    @classmethod

    19

    def format_datetime (cls, dt) :

    20

        if dt.date() == datetime.date.today() :

    21

            return dt.strftime(cls.TIME_FMT)

    22

        else :

    23

            return dt.strftime(cls.DATE_FMT)

    24

    25

    def render_starts (self) :

    26

        return self.format_datetime(self.starts)

    27

    28

    def render_ends (self) :

    29

        if self.ends :

    30

            return self.format_datetime(self.ends)

    31

        else :

    32

            return None

    33

    34

    def ends_class (self) :

    35

        if self.ends and self.ends > datetime.datetime.now() :

    36

            return 'active'

    37

        else :

    38

            return None

    39

    40

    @property

    41

    def length (self) :

    42

        if self.ends :

    43

            return self.ends - self.starts

    44

        else :

    45

            return datetime.datetime.now() - self.starts

    46

    47

    def render_length (self) :

    48

        return format_timedelta(self.length)

    49

    50

db.mapper(DHCPLease, db.dhcp_leases, properties=dict(

    51

    52

))

    53

    54

class LeasesTable (table.Table) :

    55

    """

    56

        <table> of leases.

    57

    """

    58

    59

    ITEMS   = "Leases"

    60

    COLUMNS = (

    61

        table.Column('ip',          "IP",       DHCPLease.ip,        

    62

            rowfilter   = True,

    63

        ),

    64

        table.Column('mac',         "MAC",      DHCPLease.mac,

    65

            rowfilter   = True,

    66

        ),

    67

        table.Column('hostname',    "Hostname", DHCPLease.hostname),

    68

        table.Column('starts',      "Starts",   DHCPLease.starts,       DHCPLease.render_starts),

    69

        table.Column('ends',        "Ends",     DHCPLease.ends,         DHCPLease.render_ends,

    70

            rowcss  = DHCPLease.ends_class

    71

        ),

    72

        table.Column('length',      "Lease",    DHCPLease.ends - DHCPLease.starts,  DHCPLease.render_length),

    73

    )

    74

    75

    # XXX: have to set again

    76

    ATTRS = dict((col.attr, col) for col in COLUMNS)

    77

    78

    # default

    79

    SORT = DHCPLease.starts.desc()

    80

    PAGE = 20

    81

    82

class LeasesHandler (table.TableHandler, web.DatabaseHandler) :

    83

    """

    84

        Combined database + <table>

    85

    """

    86

    87

    CSS = web.DatabaseHandler.CSS + table.TableHandler.CSS + (

    88

        "/static/dhcp/hosts.css", 

    89

    )

    90

    91

    # view

    92

    TABLE = LeasesTable

    93

    94

    def query (self) :

    95

        """

    96

            Database SELECT query.

    97

        """

    98

    99

        return self.db.query(DHCPLease)

   100

   101

    def filter_starts (self, value) :

   102

        return ((db.func.now() - DHCPLease.starts) < parse_timedelta(value))

   103

   104

    def filter_ends (self, value) :

   105

        return ((DHCPLease.ends - db.func.now()) > parse_timedelta(value))

   106

   107

    def filter_length (self, value) :

   108

        """

   109

            Filter by leases valid on given date.

   110

        """

   111

   112

        dt = datetime.datetime.strptime(value, DHCPLease.DATE_FMT)

   113

   114

        return db.between(dt, DHCPLease.starts, DHCPLease.ends)

   115

   116

    def filter_ip (self, value) :

   117

        # column is IPv4 string literal format...

   118

        if '/' in value :

   119

            return (db.func.inet(DHCPLease.ip).op('<<')(db.func.cidr(value)))

   120

        else :

   121

            return (db.func.inet(DHCPLease.ip) == db.func.inet(value))

   122

   123

   124

class ListHandler (LeasesHandler) :

   125

    """

   126

        List of DHCP leases, using table.TableHandler -> LeasesTable.

   127

    """

   128

   129

    #TABLE_ITEM_URL = ItemHandler

   130

   131

    def process (self) :

   132

        # super

   133

        table.TableHandler.process(self)

   134

   135

    def title (self) :

   136

        if self.filters :

   137

            return "DHCP Leases: {filters}".format(filters=self.filters_title())

   138

        else :

   139

            return "DHCP Leases"

   140

   141

    def render (self) :

   142

        return (

   143

            self.render_table(self.query, filters=self.filters, sort=self.sorts, page=self.page),

   144

   145

            #html.a(href=self.url())(html('«'), 'Back') if self.filters else None,

   146

        )

   147

   148

   149