1

from pvl.verkko import web, db, table

     2

from pvl.verkko.utils import parse_timedelta, IPv4Network

     3

     4

from pvl.web import html, response

     5

     6

import re

     7

import datetime

     8

import socket # dns

     9

    10

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

    11

    12

## Model

    13

import json

    14

import time

    15

    16

def dt2ts (dt) :

    17

    return int(time.mktime(dt.timetuple()))

    18

    19

def ts2dt (ts) :

    20

    return datetime.datetime.fromtimestamp(ts)

    21

    22

# TODO: this should be DHCPHost

    23

class Host (object) :

    24

    DATE_FMT = '%Y%m%d'

    25

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

    26

    27

    MAC_HEX = r'([A-Za-z0-9]{2})'

    28

    MAC_SEP = r'[-:.]?'

    29

    MAC_RE = re.compile(MAC_SEP.join([MAC_HEX] * 6))

    30

    31

    @classmethod

    32

    def normalize_mac (cls, mac) :

    33

        match = cls.MAC_RE.search(mac)

    34

    35

        if not match :

    36

            raise ValueError(mac)

    37

    38

        else :

    39

            return ':'.join(hh.lower() for hh in match.groups())

    40

    41

    def __init__ (self, ip, mac, name=None) :

    42

        self.ip = ip

    43

        self.mac = mac

    44

        self.name = name

    45

    46

    def render_mac (self) :

    47

        if not self.mac :

    48

            return None

    49

    50

        elif len(self.mac) > (6 * 2 + 5) :

    51

            return u'???'

    52

    53

        else :

    54

            return unicode(self.mac)

    55

    56

    def network (self) :

    57

        return self.gw

    58

    59

    def render_name (self) :

    60

        if self.name :

    61

            return self.name.decode('ascii', 'replace')

    62

        else :

    63

            return None

    64

    65

    STATES = {

    66

        'DHCPACK':      'ack',

    67

        'DHCPNAK':      'nak',

    68

        'DHCPRELEASE':  'release',

    69

        'DHCPDISCOVER': 'search',

    70

        'DHCPREQUEST':  'search',

    71

        'DHCPOFFER':    'search',

    72

    }

    73

    74

    def state_class (self) :

    75

        if self.error :

    76

            return 'dhcp-error'

    77

    78

        elif self.state in self.STATES :

    79

            return 'dhcp-' + self.STATES[self.state]

    80

    81

        else :

    82

            return None

    83

    84

    def state_title (self) :

    85

        return self.error # or None

    86

    87

    def render_state (self) :

    88

        if self.error :

    89

            return "{self.state}: {self.error}".format(self=self)

    90

        else :

    91

            return self.state

    92

    93

    @classmethod

    94

    def format_datetime (cls, dt) :

    95

        if (datetime.datetime.now() - dt).days :

    96

            return dt.strftime(cls.DATE_FMT)

    97

    98

        else :

    99

            return dt.strftime(cls.TIME_FMT)

   100

   101

    def seen (self) :

   102

        return (

   103

                html.span(title=self.first_seen)(self.format_datetime(self.first_seen)),

   104

                '-',

   105

                html.span(title=self.last_seen)(self.format_datetime(self.last_seen))

   106

        )

   107

   108

    def dns (self) :

   109

        """

   110

            Reverse-DNS lookup.

   111

        """

   112

   113

        if not self.ip :

   114

            return None

   115

   116

        sockaddrs = set(sockaddr for family, socktype, proto, canonname, sockaddr in socket.getaddrinfo(self.ip, 0, 0, 0, 0, socket.AI_NUMERICHOST))

   117

   118

        for sockaddr in sockaddrs :

   119

            try :

   120

                host, port = socket.getnameinfo(sockaddr, socket.NI_NAMEREQD)

   121

            except socket.gaierror :

   122

                continue

   123

   124

            return host

   125

   126

    def __unicode__ (self) :

   127

        return u"{host.ip} ({host.mac})".format(host=self)

   128

   129

db.mapper(Host, db.dhcp_hosts, properties=dict(

   130

    #id      = db.dhcp_hosts.c.rowid,

   131

    #state   = db.dhcp_hosts.c.,

   132

))

   133

   134

## Controller 

   135

class HostsTable (table.Table) :

   136

    """

   137

        <table> of hosts.

   138

    """

   139

   140

    ITEMS   = "Hosts"

   141

    COLUMNS = (

   142

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

   143

            rowfilter   = True,

   144

        ),

   145

        table.Column('mac',   "MAC",      Host.mac,       Host.render_mac,

   146

            rowfilter   = True,

   147

        ),

   148

        table.Column('name',  "Hostname", Host.name,      Host.render_name, ),

   149

        table.Column('gw',    "Network",  Host.gw,        Host.network,  ),

   150

        table.Column('seen',  "Seen",     Host.last_seen, Host.seen, ),

   151

        table.Column('state', "State",    Host.count,     

   152

            rowtitle    = Host.state_title,

   153

            rowcss      = Host.state_class,

   154

        ),

   155

    )

   156

   157

    # XXX: have to set again

   158

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

   159

   160

    # default

   161

    SORT = Host.last_seen.desc()

   162

    PAGE = 10

   163

   164

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

   165

    """

   166

        Combined database + <table>

   167

    """

   168

   169

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

   170

        "/static/dhcp/hosts.css", 

   171

    )

   172

   173

    # view

   174

    TABLE = HostsTable

   175

   176

    def query (self) :

   177

        """

   178

            Database SELECT query.

   179

        """

   180

   181

        return self.db.query(Host)

   182

   183

    def filter_seen (self, value) :

   184

        """

   185

            Return filter expression for given attr == value

   186

        """

   187

   188

        column = Host.last_seen

   189

   190

        if value.isdigit() :

   191

            # specific date

   192

            date = datetime.datetime.strptime(value, Host.DATE_FMT).date()

   193

   194

            return db.between(date.strftime(Host.DATE_FMT), 

   195

                    db.func.strftime(Host.DATE_FMT, Host.first_seen),

   196

                    db.func.strftime(Host.DATE_FMT, Host.last_seen)

   197

            )

   198

        else :

   199

            # recent

   200

            timedelta = parse_timedelta(value)

   201

   202

            return ((db.func.now() - Host.last_seen) < timedelta)

   203

   204

            # XXX: for sqlite, pgsql should handle this natively?

   205

            # to seconds

   206

            #timeout = timedelta.days * (24 * 60 * 60) + timedelta.seconds

   207

   208

            # WHERE strftime('%s', 'now') - strftime('%s', last_seen) < :timeout

   209

            #filter = (db.func.strftime('%s', 'now') - db.func.strftime('%s', Host.last_seen) < timeout)

   210

   211

    def filter_ip (self, value) :

   212

        column = Host.ip

   213

   214

        # column is IPv4 string literal format...

   215

        if '/' in value :

   216

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

   217

        else :

   218

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

   219

   220

    def filter_mac (self, value) :

   221

        return self.filter_attr('mac', Host.normalize_mac(value))

   222

   223

class ItemHandler (HostsHandler) :

   224

    """

   225

        A specific DHCP host, along with a list of related hosts.

   226

    """

   227

   228

    def process (self, id) :

   229

        self.hosts = self.query()

   230

        self.host = self.hosts.get(id)

   231

   232

        if not self.host :

   233

            raise web.NotFound("No such host: {id}".format(id=id))

   234

   235

        self.sorts, self.hosts = self.sort(self.hosts.filter((Host.ip == self.host.ip) | (Host.mac == self.host.mac)))

   236

   237

    def title (self) :

   238

        return u"DHCP Host: {self.host}".format(self=self)

   239

   240

    def render_host (self, host) :

   241

        """

   242

            Details for specific host.

   243

        """

   244

   245

        attrs = (

   246

                ('Network',     host.gw),

   247

                ('IP',          host.ip),

   248

                ('MAC',         host.mac),

   249

                ('Hostname',    host.name),

   250

                ('DNS',         host.dns()),

   251

                ('First seen',  host.first_seen),

   252

                ('Last seen',   host.last_seen),

   253

                ('Last state',  host.render_state()),

   254

                ('Total messages',      host.count),

   255

        )

   256

   257

        return (

   258

            html.dl(

   259

                (html.dt(title), html.dd(value)) for title, value in attrs

   260

            )

   261

        )

   262

   263

    def render (self) :

   264

        return (

   265

            html.h2('Host'),

   266

            self.render_host(self.host),

   267

   268

            html.h2('Related'),

   269

            self.render_table(self.hosts, sort=self.sorts, hilight=dict(ip=self.host.ip, mac=self.host.mac)),

   270

   271

            html.a(href=self.url(ListHandler))(html('«'), 'Back'),

   272

        )

   273

   274

class ListHandler (HostsHandler) :

   275

    """

   276

        List of DHCP hosts for given filter.

   277

    """

   278

   279

    TABLE_ITEM_URL = ItemHandler

   280

   281

    def process (self) :

   282

        # super

   283

        table.TableHandler.process(self)

   284

   285

    def title (self) :

   286

        if self.filters :

   287

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

   288

        else :

   289

            return "DHCP Hosts"

   290

   291

    def render (self) :

   292

        return (

   293

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

   294

   295

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

   296

        )

   297

   298

class RealtimeHandler (HostsHandler) :

   299

    TITLE = "DHCP Hosts: Pseudo-Realtime.."

   300

    CSS = HostsHandler.CSS + (

   301

        'http://code.jquery.com/ui/1.9.0/themes/base/jquery-ui.css',

   302

    )

   303

    JS = (

   304

        #"/static/jquery/jquery.js",

   305

        'http://code.jquery.com/jquery-1.8.2.js',

   306

        'http://code.jquery.com/ui/1.9.0/jquery-ui.js',

   307

        '/static/dhcp/spin.js',

   308

        '/static/dhcp/table.js',

   309

        '/static/dhcp/hosts.js',

   310

    )

   311

   312

    COLUMNS = (

   313

        ( 'ip',     'IP',           lambda host: host.ip    ),

   314

        ( 'mac',    'MAC',          lambda host: host.mac   ),

   315

        ( 'name',   'Hostname',     lambda host: host.name  ),

   316

        ( 'gw',     'Network',      lambda host: host.gw    ),

   317

        ( 'seen',   'Seen',         Host.seen,              ),

   318

        ( 'state',  'State',        lambda host: host.state ),

   319

    )

   320

   321

    def process (self) :

   322

        """

   323

            Either return JSON (if ?t=...), or fetch hosts/t for rendering.

   324

        """

   325

   326

        t = self.request.args.get('t')

   327

   328

        if t :

   329

            # return json

   330

            t = ts2dt(int(t))

   331

   332

        # query

   333

        hosts = self.query()

   334

   335

        # always sorted by last_seen

   336

        hosts = hosts.order_by(Host.last_seen.desc())

   337

   338

        # filter

   339

        self.filters, hosts = self.filter(hosts)

   340

   341

        if t :

   342

            # return json

   343

            hosts = hosts.filter(Host.last_seen > t)

   344

            hosts = list(hosts)

   345

            hosts.reverse()

   346

   347

            if hosts :

   348

                # update timestamp to most recent

   349

                t = hosts[-1].last_seen

   350

   351

            # json

   352

            data = dict(

   353

                t       = dt2ts(t),

   354

                hosts   = [dict(self.table.json(host)) for host in hosts],

   355

            )

   356

   357

            return response.json(data)

   358

   359

        else :

   360

            # render html

   361

            hosts = hosts.limit(self.table.PAGE)

   362

   363

            # XXX: testing

   364

            hosts = hosts.offset(1)

   365

   366

            # extract timestamp

   367

            for host in hosts :

   368

                self.t = host.last_seen

   369

   370

                break

   371

   372

            else :

   373

                # no hosts :<

   374

                self.t = datetime.datetime.now()

   375

   376

            # store

   377

            self.hosts = hosts

   378

   379

    def title (self) :

   380

        if self.filters :

   381

            return "{title}: {filters}".format(title=self.TITLE, filters=self.filters_title())

   382

        else :

   383

            return self.TITLE

   384

   385

    def render (self) :

   386

        """

   387

            Render page HTML and initial <table>, along with bootstrap JS (t0, configuration).

   388

        """

   389

   390

        return html.div(id='wrapper')(

   391

            html.input(type='submit', id='refresh', value="Refresh"),

   392

            html.input(type='reset', id='pause', value="Pause"),

   393

   394

            self.table.render(self.hosts)(id='hosts-realtime'),

   395

   396

            html.script(type='text/javascript')(

   397

                """

   398

$(document).ready(HostsRealtime(Table($('#hosts-realtime'), {table_params}), {params}));

   399

                """.format(

   400

                    table_params = json.dumps(dict(

   401

                        item_url        = self.url(ItemHandler, id='0'),

   402

                        columns         = [column.attr for column in self.table.columns],

   403

                    )),

   404

                    params = json.dumps(dict(

   405

                        url     = self.url(),

   406

                        filters = self.filters,

   407

                        t       = dt2ts(self.t),

   408

                    )),

   409

                )

   410

            )

   411

        )

   412